penchant 0.1.2 → 0.2.1

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+.DS_Store

data/Gemfile

@@ -13,3 +13,4 @@ gem 'rspec', '~> 2.6.0'
 gem 'rake'
 
 gem 'cucumber'
+gem 'cuke-pack', :path => '../cuke-pack'

data/Guardfile

@@ -9,10 +9,13 @@ group :rspec do
   end
 end
 
-group :cucumber do
-  guard 'cucumber' do
-    watch(%r{^features/.+\.feature$})
+# added by cuke-pack
+
+group :wip do
+  guard 'cucumber', :env => :cucumber, :cli => '-p wip' do
+    watch(%r{^features/.+.feature$})
+    watch(%r{^(app|lib).*})          { 'features' }
     watch(%r{^features/support/.+$})          { 'features' }
-    watch(%r{^features/step_definitions/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
+    watch(%r{^features/step_definitions/(.+).rb$}) { 'features' }
   end
 end

data/README.md

@@ -3,7 +3,7 @@
 I like to do these things in all my projects:
 
 * Have all my tests run before committing. I don't like buying ice cream for the team on test failures.
-* If I'm developing gems alongside this project, I use a `Gemfile.erb` to get around the "one gem, one source" issue in
+* If I'm developing gems alongside this project, I use a `Gemfile.penchant` to get around the "one gem, one source" issue in
   current versions of Bundler.
 * If I'm moving to different machines or (heaven forbid!) having other developers work on the project, I want to make
   getting all those local gems as easy as possible.
@@ -14,27 +14,36 @@ This gem makes that easier!
 
 Installs a bunch of scripts into the `scripts` directory of your project:
 
-* `gemfile` which switches between `Gemfile.erb` environments
+* `gemfile` which switches between `Gemfile.penchant` environments
 * `install-git-hooks` which will do just what it says
 * `hooks`, several git hooks that the prior script symlinks into .git/hooks for you
 * `initialize-environment`, which bootstraps your local environment so you can get up and running
 
-## Gemfile.erb?!
+## Gemfile.penchant?!
 
-Yeah, it's a `Gemfile` with ERB in it:
+Yeah, it's a `Gemfile` with some extras:
 
-``` erb
-<% env :local do %>
-  gem 'guard', :path => '../guard'
-<% end %>
+``` ruby
+source :rubygems
+
+gem 'rails', '3.2.3'
+gems 'rake', 'nokogiri', 'rack-rewrite'
+
+no_deployment do
+  group :development, :test do
+    gem 'rspec', '~> 2.6.0'
 
-<% env :remote do %>
-  gem 'guard', :git => 'git://github.com/johnbintz/guard.git'
-<% end %>
+    dev_gems = %w{flowerbox guard-flowerbox}
 
-<% no_deployment do %>
-  gem 'os-specific-things'
-<% end %>
+    env :local do
+      gems dev_gems, :path => '../%s'
+    end
+
+    env :remote do
+      gems dev_gems, :git => 'git://github.com/johnbintz/%s.git'
+    end
+  end
+end
 ```
 
 Use `script/gemfile local` to get at the local ones, and `script/gemfile remote` to get at the remote ones.
@@ -49,8 +58,8 @@ remote servers. *Very* helpful when you have OS-specific gems and are developing
 and deploying on another, or if you don't want to deal with the dependencies for your testing
 frameworks:
 
-``` erb
-<% no_deployment do %>
+``` ruby
+no_deployment do
   require 'rbconfig'
   case RbConfig::CONFIG['host_os']
   when /darwin/
@@ -64,7 +73,7 @@ frameworks:
   group :test do
     # ... all your testing libraries you won't need on the deployed end ...
   end
-<% end %>
+end
 ```
 
 Run `penchant gemfile ENV --deployment` to get this behavior. This is run by default when the
@@ -74,8 +83,8 @@ pre-commit git hook runs, but only after the default Rake task passes.
 
 Get new developers up to speed fast! `script/initialize-environment` does the following when run:
 
-* Check out any remote repos found in `Gemfile.erb` to the same directory where your current project lives.
-  That way, you can have your `Gemfile.erb` set up as above and everything works cleanly.
+* Check out any remote repos found in `Gemfile.penchant` to the same directory where your current project lives.
+  That way, you can have your `Gemfile.penchant` set up as above and everything works cleanly.
 * Runs `script/gemfile remote` to set your project to using remote repositories.
 * Runs `rake bootstrap` for the project if it exists.
 

data/bin/penchant

@@ -30,7 +30,7 @@ class PenchantCLI < Thor
   method_options :dir => 'script'
   def convert
     install
-    FileUtils.mv 'Gemfile', 'Gemfile.erb'
+    FileUtils.mv 'Gemfile', 'Gemfile.penchant'
     gemfile(:remote)
   end
 
@@ -52,7 +52,7 @@ class PenchantCLI < Thor
 
     gemfile = Penchant::Gemfile.new
     if !gemfile.has_gemfile?
-      puts "No Gemfile or Gemfile.erb, exiting."
+      puts "No Gemfile or Gemfile.penchant, exiting."
       exit 1
     end
     system %{bundle}

data/config/cucumber.yml

@@ -0,0 +1,8 @@
+<%
+std_opts = "-r features --format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} -f Cucumber::StepWriter --out features/step_definitions --strict"
+%>
+default: <%= std_opts %> features
+wip: <%= std_opts %> --tags @wip features
+precommit: FAILFAST=true <%= std_opts %> --tags ~@wip:0 features
+cleanup: <%= std_opts %> -f Cucumber::CleanupFormatter --out unused.txt features
+

data/features/gemfile.feature

@@ -31,3 +31,76 @@ Feature: Gemfiles
       # generated by penchant, environment: local
       this is content
       """
+
+  Scenario: Use placeholder expansion
+    Given I have the file "Gemfile.erb" with the content:
+      """
+      <% env :local, :path => '../%s' do %>
+        gem 'test'
+      <% end %>
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following stripped content:
+      """
+      # generated by penchant, environment: local
+      gem 'test', :path => %{../test}
+      """
+
+  Scenario: Use a gem list for an operation
+    Given I have the file "Gemfile.erb" with the content:
+      """
+      <% gems 'test' do %>
+        <% env :local, :path => '../%s' do %>
+          <%= gem %>
+        <% end %>
+      <% end %>
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following stripped content:
+      """
+      # generated by penchant, environment: local
+      gem 'test', :path => %{../test}
+      """
+  
+  Scenario: Let gem get additional info
+    Given I have the file "Gemfile.erb" with the content:
+      """
+      <% gems 'test' do %>
+        <%= gem :path => '../%s' %>
+      <% end %>
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+
+        gem 'test', {:path=>"../test"}
+
+      """
+  
+  Scenario: Use a gem list without a block
+    Given I have the file "Gemfile.erb" with the content:
+      """
+      <% gems 'test', :path => '../%s' %>
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+      gem 'test', {:path=>"../test"}
+
+      """
+
+  Scenario: Use a gem list with an array
+    Given I have the file "Gemfile.erb" with the content:
+      """
+      <% gems [ 'test' ], :path => '../%s' %>
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+      gem 'test', {:path=>"../test"}
+
+      """
+

data/features/ruby_gemfile.feature

@@ -0,0 +1,131 @@
+@fakefs
+Feature: Gemfiles
+  Scenario: Process a pure Ruby gemfile
+    Given I have the file "Gemfile.penchant" with the content:
+      """
+      source :rubygems
+
+      group :cats, :dogs do
+        case environment
+        when :local
+          gem 'test', :path => '../test'
+        when :remote
+          gem 'test', :git => 'git://github.com/johnbintz/test.git'
+        end
+      end
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+      source :rubygems
+
+      group :cats, :dogs do
+        gem "test", {:path=>"../test"}
+      end
+      """
+    When I rebuild the Gemfile for "remote" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: remote
+      source :rubygems
+
+      group :cats, :dogs do
+        gem "test", {:git=>"git://github.com/johnbintz/test.git"}
+      end
+      """
+
+  Scenario: Use a gemlist
+    Given I have the file "Gemfile.penchant" with the content:
+      """
+      gems 'one', 'two', 'three', :path => '../%s'
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+      gem "one", {:path=>"../one"}
+      gem "two", {:path=>"../two"}
+      gem "three", {:path=>"../three"}
+      """
+
+  Scenario: Use an env block
+    Given I have the file "Gemfile.penchant" with the content:
+      """
+      env :local do
+        gems 'one', 'two', 'three', :path => '../%s'
+      end
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+      gem "one", {:path=>"../one"}
+      gem "two", {:path=>"../two"}
+      gem "three", {:path=>"../three"}
+      """
+
+    When I rebuild the Gemfile for "remote" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: remote
+
+      """
+
+  Scenario: Skip deployment blocks
+    Given I have the file "Gemfile.penchant" with the content:
+      """
+      no_deployment do
+        gem 'one'
+      end
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+      gem "one"
+      """
+
+    When I rebuild the Gemfile for "local" mode with deployment
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local, deployment mode (was local)
+
+      """
+
+  Scenario: Peel multiple hashes off a gemlist
+    Given I have the file "Gemfile.penchant" with the content:
+      """
+      gems 'one', { :path => '../%s' }, { :require => nil }
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+      gem "one", {:path=>"../one", :require=>nil}
+      """
+
+  Scenario: Don't add an empty hash
+    Given I have the file "Gemfile.penchant" with the content:
+      """
+      gems 'one'
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+      gem "one"
+      """
+
+  Scenario: Single gem gets processed like a gems list
+    Given I have the file "Gemfile.penchant" with the content:
+      """
+      gem 'one', :path => '../%s'
+      """
+    When I rebuild the Gemfile for "local" mode
+    Then the file "Gemfile" should have the following content:
+      """
+      # generated by penchant, environment: local
+      gem "one", {:path=>"../one"}
+      """
+

data/features/step_definitions/then/the_file_gemfile_should_have_the_following_stripped_content.rb

@@ -0,0 +1,7 @@
+Then /^the file "(.*?)" should have the following stripped content:$/ do |file, string|
+  test_lines = string.lines.to_a
+
+  File.read(file).lines.collect(&:strip).reject(&:empty?).to_a.each do |line|
+    line.strip.should == test_lines.shift.strip
+  end
+end

data/features/step_definitions/when/i_rebuild_the_gemfile_for_local_mode.rb

@@ -0,0 +1,4 @@
+When /^I rebuild the Gemfile for "(.*?)" mode$/ do |env|
+  Penchant::Gemfile.do_full_env_switch!(env)
+end
+

data/features/support/cuke-pack.rb

@@ -0,0 +1,20 @@
+require 'cuke-pack/support/pause'
+require 'cuke-pack/support/pending'
+
+Before do
+  # if you want pending steps to pause before marking the step as pending,
+  # set @pause_ok to true
+
+  @pause_ok = false
+end
+
+require 'cuke-pack/support/step_writer'
+require 'cuke-pack/support/wait_for'
+require 'cuke-pack/support/failfast'
+
+# set the level of flaying on the step definitions
+# set it to false to skip flaying
+flay_level = 32
+
+require 'cuke-pack/support/flay'
+

data/features/support/env.rb

@@ -6,6 +6,7 @@ Before('@fakefs') do
 end
 
 After do
+  FakeFS::FileSystem.clear
   FakeFS.deactivate!
 
   FileUtils.rm_rf 'tmp'

data/lib/penchant/gemfile.rb

@@ -18,7 +18,7 @@ module Penchant
 
     def self.pre_switch(env, deployment = false)
       gemfile = Penchant::Gemfile.new
-      return false if !gemfile.has_gemfile_erb?
+      return false if !gemfile.has_processable_gemfile?
       gemfile.run_dot_penchant!(env, deployment)
 
       gemfile
@@ -46,10 +46,26 @@ module Penchant
       file_in_path('Gemfile.erb')
     end
 
+    def gemfile_penchant_path
+      file_in_path('Gemfile.penchant')
+    end
+
     def has_gemfile_erb?
       File.file?(gemfile_erb_path)
     end
 
+    def has_gemfile_penchant?
+      File.file?(gemfile_penchant_path)
+    end
+
+    def has_processable_gemfile?
+      has_gemfile_erb? || has_gemfile_penchant?
+    end
+
+    def processable_gemfile_path
+      has_gemfile_erb? ? gemfile_erb_path : gemfile_penchant_path
+    end
+
     def environment
       gemfile_header.strip[%r{environment: ([^, ]*)}, 1]
     end
@@ -58,10 +74,170 @@ module Penchant
       gemfile_header['deployment mode'] != nil
     end
 
+    class FileProcessor
+      attr_reader :environment, :is_deployment
+
+      def self.result(data, *args)
+        new(data).result(*args)
+      end
+
+      def self.handle_result(&block)
+        if block
+          @handle_result = block
+        else
+          @handle_result
+        end
+      end
+
+      def initialize(data)
+        @data = data
+      end
+
+      def result(_env, _is_deployment)
+        @environment = _env.to_s.to_sym
+        @is_deployment = _is_deployment
+
+        @output = []
+
+        handle_result(@data)
+
+        @output.join("\n")
+      end
+
+      def env(*args)
+        yield if args.include?(environment)
+      end
+
+      def no_deployment
+        yield if !is_deployment
+      end
+
+      protected
+      def args_to_string(args)
+        args.inspect[1..-2]
+      end
+
+      def split_args(args)
+        template = {}
+
+        while args.last.instance_of?(Hash)
+          template.merge!(args.pop)
+        end
+
+        [ args, template ]
+      end
+
+      def call_and_indent_output(block)
+        index = @output.length
+        block.call
+        index.upto(@output.length - 1) do |i|
+          @output[i] = "  " + @output[i]
+        end
+      end
+
+      def process_options(gem_name, template = {})
+        Hash[
+          template.collect { |key, value|
+            value = value % gem_name if value.respond_to?(:%)
+
+            [ key, value ]
+          }.sort
+        ]
+      end
+    end
+
+    class ERBFile < FileProcessor
+      def handle_result(data)
+        @output << ERB.new(data, nil, nil, '@_erbout').result(binding)
+      end
+
+      def env(check, template = {}, &block)
+        if check.to_s == @env.to_s
+          original_erbout = @_erbout.dup
+
+          output = instance_eval(&block).lines.to_a
+
+          output.each do |line|
+            if gem_name = line[%r{gem ['"]([^'"]+)['"]}, 1]
+              line.replace(line.rstrip + process_options(gem_name, template) + "\n")
+            end
+          end
+
+          @_erbout = original_erbout + output.join
+        end
+      end
+
+      def gems(*gems)
+        template = {}
+        template = gems.pop if gems.last.instance_of?(Hash)
+
+        gems.flatten.each do |gem|
+          @_current_gem = gem
+          if block_given?
+            yield
+          else
+            @_erbout += gem(template) + "\n"
+          end
+        end
+      end
+
+      def gem(template = {})
+        output = "gem '#{@_current_gem}'" 
+        options = process_options(@_current_gem, template)
+        if !options.empty?
+          output += ", #{options.inspect}"
+        end
+        output
+      end
+    end
+
+    class PenchantFile < FileProcessor
+      def handle_result(data)
+        instance_eval(data)
+      end
+
+      def gem(*args)
+        gem_name, template = split_args(args)
+
+        options = process_options(gem_name, template)
+
+        args = [ gem_name.first ]
+        args << options if !options.empty?
+
+        @output << %{gem #{args_to_string(args)}}
+      end
+
+      def gems(*args)
+        gems, template = split_args(args)
+
+        gems.flatten.each do |gem_name|
+          options = process_options(gem_name, template)
+
+          args = [ gem_name ]
+          args << options if !options.empty?
+
+          gem *args
+        end
+      end
+
+      def group(*args, &block)
+        @output << ""
+        @output << %{group #{args_to_string(args)} do}
+
+        call_and_indent_output(block)
+
+        @output << %{end}
+      end
+
+      def source(*args)
+        @output << %{source #{args_to_string(args)}}
+      end
+    end
+
     def switch_to!(gemfile_env = nil, deployment = false)
       @env, @is_deployment = gemfile_env, deployment
 
-      output = [ header, ERB.new(template).result(binding) ]
+      output = [ header, process(template) ]
 
       File.open(gemfile_path, 'wb') { |fh| fh.print output.join("\n") }
     end
@@ -93,16 +269,19 @@ module Penchant
       File.join(@path, file)
     end
 
-    def template
-      File.read(gemfile_erb_path)
-    end
+    def process(template)
+      builder = case File.extname(processable_gemfile_path)
+      when '.penchant'
+        PenchantFile
+      when '.erb'
+        ERBFile
+      end
 
-    def env(check, &block)
-      instance_eval(&block) if check.to_s == @env.to_s
+      builder.result(template, @env, @is_deployment)
     end
 
-    def no_deployment(&block)
-      instance_eval(&block) if !@is_deployment
+    def template
+      File.read(processable_gemfile_path)
     end
 
     def gemfile_header

data/lib/penchant/version.rb

@@ -1,3 +1,3 @@
 module Penchant
-  VERSION = "0.1.2"
+  VERSION = "0.2.1"
 end

data/script/hooks/commit-msg

@@ -14,11 +14,3 @@ if [[ "${msg}" != *"[ci skip]"* ]]; then
   if [ $R -ne 0 ]; then exit $R; fi
 fi
 
-if [ "$(penchant gemfile-env)" != "remote deployment" ]; then
-  unset GIT_DIR
-  penchant gemfile remote --deployment
-  GIT_DIR=$OLD_GIT_DIR
-  git add Gemfile*
-fi
-
-exit 0

data/template/script/hooks/commit-msg

@@ -6,7 +6,9 @@ OLD_GIT_DIR=$GIT_DIR
 
 if [[ "${msg}" != *"[ci skip]"* ]]; then
   if [ "$(penchant gemfile-env)" != "remote" ]; then
+    unset GIT_DIR
     penchant gemfile remote
+    GIT_DIR=$OLD_GIT_DIR
   fi
 
   bundle exec rake
@@ -14,11 +16,3 @@ if [[ "${msg}" != *"[ci skip]"* ]]; then
   if [ $R -ne 0 ]; then exit $R; fi
 fi
 
-if [ "$(penchant gemfile-env)" != "remote deployment" ]; then
-  unset GIT_DIR
-  penchant gemfile remote --deployment
-  GIT_DIR=$OLD_GIT_DIR
-  git add Gemfile*
-fi
-
-exit 0

data/template/script/hooks/pre-commit

@@ -1,4 +1,7 @@
 #!/bin/bash
 
-# this has been moved to commit-msg
+unset GIT_DIR
+penchant gemfile remote --deployment
+GIT_DIR=$OLD_GIT_DIR
+git add Gemfile*
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: penchant
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-20 00:00:00.000000000 Z
+date: 2012-06-05 00:00:00.000000000 Z
 dependencies: []
 description: Things I do for my Rails projects to get up to speed in new environments
   fast
@@ -26,14 +26,19 @@ files:
 - README.md
 - Rakefile
 - bin/penchant
+- config/cucumber.yml
 - features/cli.feature
 - features/gemfile.feature
+- features/ruby_gemfile.feature
 - features/step_definitions/given/i_have_the_file_with_content.rb
+- features/step_definitions/then/the_file_gemfile_should_have_the_following_stripped_content.rb
 - features/step_definitions/then/the_file_should_have_content.rb
 - features/step_definitions/then/the_output_should_include.rb
+- features/step_definitions/when/i_rebuild_the_gemfile_for_local_mode.rb
 - features/step_definitions/when/i_rebuild_the_gemfile_switching_back.rb
 - features/step_definitions/when/i_rebuild_the_gemfile_with_deployment.rb
 - features/step_definitions/when/i_run_in.rb
+- features/support/cuke-pack.rb
 - features/support/env.rb
 - lib/penchant.rb
 - lib/penchant/dot_penchant.rb
@@ -70,7 +75,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 826851711402513730
+      hash: -4406262957412417452
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -79,10 +84,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 826851711402513730
+      hash: -4406262957412417452
 requirements: []
 rubyforge_project: penchant
-rubygems_version: 1.8.17
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Things I do for my Rails projects to get up to speed in new environments
@@ -90,12 +95,16 @@ summary: Things I do for my Rails projects to get up to speed in new environment
 test_files:
 - features/cli.feature
 - features/gemfile.feature
+- features/ruby_gemfile.feature
 - features/step_definitions/given/i_have_the_file_with_content.rb
+- features/step_definitions/then/the_file_gemfile_should_have_the_following_stripped_content.rb
 - features/step_definitions/then/the_file_should_have_content.rb
 - features/step_definitions/then/the_output_should_include.rb
+- features/step_definitions/when/i_rebuild_the_gemfile_for_local_mode.rb
 - features/step_definitions/when/i_rebuild_the_gemfile_switching_back.rb
 - features/step_definitions/when/i_rebuild_the_gemfile_with_deployment.rb
 - features/step_definitions/when/i_run_in.rb
+- features/support/cuke-pack.rb
 - features/support/env.rb
 - spec/lib/penchant/dot_penchant_spec.rb
 - spec/lib/penchant/gemfile_spec.rb