berkshelf 0.4.0.rc1 → 0.4.0.rc2

data/bin/berks

@@ -2,4 +2,9 @@
 $:.push File.expand_path("../../lib", __FILE__)
 require 'berkshelf'
 
-Berkshelf::Cli.start
+begin
+  Berkshelf::Cli.start
+rescue Berkshelf::BerkshelfError => e
+  Berkshelf.ui.fatal e
+  exit e.status_code
+end

data/features/cookbook_command.feature

@@ -0,0 +1,39 @@
+Feature: cookbook command
+  As a Cookbook author  
+  I want a way to quickly generate a Cookbook skeleton that contains supporting Berkshelf files
+  So I can quickly and automatically generate a Cookbook containing Berkshelf supporting files or other common supporting files
+
+  Scenario: creating a new cookbook skeleton
+    When I run the cookbook command to create "sparkle_motion"
+    Then I should have a new cookbook skeleton "sparkle_motion"
+    And the exit status should be 0
+
+  Scenario: creating a new cookbook skeleton with Vagrant support
+    When I run the cookbook command to create "sparkle_motion" with options:
+      | --vagrant |
+    Then I should have a new cookbook skeleton "sparkle_motion" with Vagrant support
+    And the exit status should be 0
+
+  Scenario: creating a new cookbook skeleton with Git support
+    When I run the cookbook command to create "sparkle_motion" with options:
+      | --git |
+    Then I should have a new cookbook skeleton "sparkle_motion" with Git support
+    And the exit status should be 0
+
+  Scenario: creating a new cookbook skeleton with Foodcritic support
+    When I run the cookbook command to create "sparkle_motion" with options:
+      | --foodcritic |
+    Then I should have a new cookbook skeleton "sparkle_motion" with Foodcritic support
+    And the exit status should be 0
+
+  Scenario: creating a new cookbook skeleton with SCMVersion support
+    When I run the cookbook command to create "sparkle_motion" with options:
+      | --scmversion |
+    Then I should have a new cookbook skeleton "sparkle_motion" with SCMVersion support
+    And the exit status should be 0
+
+  Scenario: creating a new cookbook skeleton without Bundler support
+    When I run the cookbook command to create "sparkle_motion" with options:
+      | --no-bundler |
+    Then I should have a new cookbook skeleton "sparkle_motion" without Bundler support
+    And the exit status should be 0

data/features/step_definitions/cli_steps.rb

@@ -54,6 +54,14 @@ When /^I run the upload command$/ do
   run_simple(unescape("berks upload"), true)
 end
 
+When /^I run the cookbook command to create "(.*?)"$/ do |name|
+  run_simple(unescape("berks cookbook #{name}"))
+end
+
+When /^I run the cookbook command to create "(.*?)" with options:$/ do |name, options|
+  run_simple(unescape("berks cookbook #{name} #{options.raw.join(" ")}"))
+end
+
 Then /^the CLI should exit with the status code for error "(.*?)"$/ do |error_constant|
   exit_status = Berkshelf.const_get(error_constant).status_code
   assert_exit_status(exit_status)

data/features/step_definitions/filesystem_steps.rb

@@ -32,7 +32,6 @@ Given /^the cookbook store contains a cookbook "(.*?)" "(.*?)" with dependencies
   generate_cookbook(cookbook_store, name, version, dependencies: dependencies.raw)
 end
 
-
 Then /^the cookbook store should have the cookbooks:$/ do |cookbooks|
   cookbooks.raw.each do |name, version|
     cookbook_store.should have_structure {
@@ -65,10 +64,130 @@ Then /^the cookbook store should not have the cookbooks:$/ do |cookbooks|
   end
 end
 
+Then /^I should have the cookbook "(.*?)"$/ do |name|
+  Pathname.new(current_dir).join(name).should be_cookbook
+end
+
+Then /^I should have a new cookbook skeleton "(.*?)"$/ do |name|
+  cb_path = Pathname.new(current_dir).join(name)
+  cb_path.should have_structure {
+    directory "attributes"
+    directory "definitions"
+    directory "files" do
+      directory "default"
+    end
+    directory "libraries"
+    directory "providers"
+    directory "recipes" do
+      file "default.rb"
+    end
+    directory "resources"
+    directory "templates" do
+      directory "default"
+    end
+    file "README.md"
+    file "metadata.rb"
+    file "Berksfile" do
+      contains "metadata"
+    end
+    file "chefignore"
+    file "Berksfile"
+    file "Gemfile" do
+      contains "gem 'berkshelf'"
+    end
+  }
+end
+
+Then /^I should have a new cookbook skeleton "(.*?)" with Vagrant support$/ do |name|
+  steps %Q{ Then I should have a new cookbook skeleton "#{name}" }
+
+  cb_path = Pathname.new(current_dir).join(name)
+  cb_path.should have_structure {
+    file "Gemfile" do
+      contains "gem 'vagrant'"
+    end
+    file "Vagrantfile" do
+      contains "recipe[#{name}::default]"
+    end
+    directory "cookbooks" do
+      directory name
+    end
+  }
+end
+
+Then /^I should have a new cookbook skeleton "(.*?)" with Git support$/ do |name|
+  steps %Q{ Then I should have a new cookbook skeleton "#{name}" }
+
+  cb_path = Pathname.new(current_dir).join(name)
+  cb_path.should have_structure {
+    file ".gitignore"
+  }
+end
+
+Then /^I should have a new cookbook skeleton "(.*?)" with Foodcritic support$/ do |name|
+  steps %Q{ Then I should have a new cookbook skeleton "#{name}" }
+
+  cb_path = Pathname.new(current_dir).join(name)
+  cb_path.should have_structure {
+    file "Gemfile" do
+      contains "gem 'thor-foodcritic'"
+    end
+    file "Thorfile" do
+      contains "require 'thor/foodcritic'"
+    end
+  }
+end
+
+Then /^I should have a new cookbook skeleton "(.*?)" with SCMVersion support$/ do |name|
+  steps %Q{ Then I should have a new cookbook skeleton "#{name}" }
+
+  cb_path = Pathname.new(current_dir).join(name)
+  cb_path.should have_structure {
+    file "Gemfile" do
+      contains "gem 'thor-scmversion'"
+    end
+    file "Thorfile" do
+      contains "require 'thor/scmversion'"
+    end
+  }
+end
+
+Then /^I should have a new cookbook skeleton "(.*?)" without Bundler support$/ do |name|
+  cb_path = Pathname.new(current_dir).join(name)
+  cb_path.should have_structure {
+    directory "attributes"
+    directory "definitions"
+    directory "files" do
+      directory "default"
+    end
+    directory "libraries"
+    directory "providers"
+    directory "recipes" do
+      file "default.rb"
+    end
+    directory "resources"
+    directory "templates" do
+      directory "default"
+    end
+    file "README.md"
+    file "metadata.rb"
+    file "Berksfile" do
+      contains "metadata"
+    end
+    file "chefignore"
+    file "Berksfile"
+    no_file "Gemfile"
+  }
+end
+
 Then /^the cookbook "(.*?)" should have the following files:$/ do |name, files|
   check_file_presence(files.raw.map{|file_row| File.join(name, file_row[0])}, true)
 end
 
+Then /^the cookbook "(.*?)" should not have the following files:$/ do |name, files|
+  check_file_presence(files.raw.map{|file_row| File.join(name, file_row[0])}, false)
+end
+
 Then /^the file "(.*?)" in the cookbook "(.*?)" should contain:$/ do |file_name, cookbook_name, content|
   Pathname.new(current_dir).join(cookbook_name).should have_structure {
     file "Berksfile" do

data/features/support/env.rb

@@ -32,7 +32,7 @@ Spork.prefork do
   end
 
   def cookbook_store
-    Pathname.new(ENV["BERKSHELF_PATH"])
+    Pathname.new(File.join(ENV["BERKSHELF_PATH"],"cookbooks"))
   end
 
   def clean_cookbook_store

data/lib/berkshelf.rb

@@ -24,7 +24,9 @@ module Berkshelf
   autoload :Git, 'berkshelf/git'
   autoload :Berksfile, 'berkshelf/berksfile'
   autoload :Lockfile, 'berkshelf/lockfile'
+  autoload :BaseGenerator, 'berkshelf/base_generator'
   autoload :InitGenerator, 'berkshelf/init_generator'
+  autoload :CookbookGenerator, 'berkshelf/cookbook_generator'
   autoload :CookbookSource, 'berkshelf/cookbook_source'
   autoload :CookbookStore, 'berkshelf/cookbook_store'
   autoload :CachedCookbook, 'berkshelf/cached_cookbook'
@@ -49,17 +51,27 @@ module Berkshelf
       @ui ||= Chef::Knife::UI.new(null_stream, null_stream, STDIN, {})
     end
 
-    # Returns the filepath to the location Cookbooks will be downloaded to
-    # or uploaded from. By default this is '~/.berkshelf' but can be overridden
-    # by specifying a value for the ENV variable 'BERKSHELF_PATH'.
+    # Returns the filepath to the location Berskhelf will use for
+    # storage; temp files will go here, Cookbooks will be downloaded
+    # to or uploaded from here. By default this is '~/.berkshelf' but
+    # can be overridden by specifying a value for the ENV variable
+    # 'BERKSHELF_PATH'.
     # 
     # @return [String]
     def berkshelf_path
       ENV["BERKSHELF_PATH"] || DEFAULT_STORE_PATH
     end
 
+    def tmp_dir
+      File.join(berkshelf_path, "tmp")
+    end
+
+    def cookbooks_dir
+      File.join(berkshelf_path, "cookbooks")
+    end
+
     def cookbook_store
-      @cookbook_store ||= CookbookStore.new(berkshelf_path)
+      @cookbook_store ||= CookbookStore.new(cookbooks_dir)
     end
 
     def downloader

data/lib/berkshelf/base_generator.rb

@@ -0,0 +1,20 @@
+require 'thor/group'
+
+module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class BaseGenerator < Thor::Group
+    class << self
+      def source_root
+        File.expand_path(File.join(File.dirname(__FILE__), "generator_files"))
+      end
+    end
+    
+    include Thor::Actions
+
+    private
+
+      def target
+        @target ||= Pathname.new(File.expand_path(path))
+      end
+  end
+end

data/lib/berkshelf/berksfile.rb

@@ -6,18 +6,12 @@ module Berkshelf
     class << self
       def from_file(file)
         content = File.read(file)
-        read(content)
+        object = new(file)
+        object.load(content)
       rescue Errno::ENOENT => e
         raise BerksfileNotFound, "No Berksfile or Berksfile.lock found at: #{file}"
       end
 
-      def read(content)
-        object = new
-        object.instance_eval(content)
-
-        object
-      end
-
       # @param [Array] sources
       #   an array of sources to filter
       # @param [Array, Symbol] excluded
@@ -34,7 +28,10 @@ module Berkshelf
       end
     end
 
-    def initialize
+    attr_reader :filepath
+
+    def initialize(path)
+      @filepath = path
       @sources = Hash.new
     end
 
@@ -190,7 +187,7 @@ module Berkshelf
       if descendant_directory?(path, Dir.pwd)
         actual_path = path
         FileUtils.rm_rf(actual_path)
-        path = Dir.mktmpdir("berkshelf-")
+        path = File.join(Berkshelf.tmp_dir, "shims")
       end
 
       FileUtils.mkdir_p(path)
@@ -205,6 +202,17 @@ module Berkshelf
       end
     end
 
+    # Reload this instance of Berksfile with the given content. The content
+    # is a string that may contain terms from the included DSL.
+    #
+    # @param [String] content
+    #
+    # @return [Berksfile]
+    def load(content)
+      instance_eval(content)
+      self
+    end
+
     private
 
       def descendant_directory?(candidate, parent)

data/lib/berkshelf/cli.rb

@@ -10,9 +10,6 @@ module Berkshelf
       ::Berkshelf.ui = Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
       ::Berkshelf.config_path = @options[:config]
       @options = options.dup # unfreeze frozen options Hash from Thor
-    rescue BerkshelfError => e
-      Berkshelf.ui.fatal e
-      exit e.status_code
     end
 
     namespace "berkshelf"
@@ -21,6 +18,7 @@ module Berkshelf
     map 'up'        => :upload
     map 'ud'        => :update
     map 'ver'       => :version
+    map 'book'      => :cookbook
 
     class_option :config,
       type: :string,
@@ -50,9 +48,6 @@ module Berkshelf
     def install
       berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
       berksfile.install(options)
-    rescue BerkshelfError => e
-      Berkshelf.ui.fatal e
-      exit e.status_code
     end
 
     method_option :berksfile,
@@ -70,9 +65,6 @@ module Berkshelf
     def update
       Lockfile.remove!
       invoke :install
-    rescue BerkshelfError => e
-      Berkshelf.ui.fatal e
-      exit e.status_code
     end
 
     method_option :berksfile,
@@ -99,25 +91,18 @@ module Berkshelf
       Berkshelf.load_config 
       berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
       berksfile.upload(Chef::Config[:chef_server_url], options)
-    rescue BerkshelfError => e
-      Berkshelf.ui.fatal e
-      exit e.status_code
     end
 
-    desc "init [PATH]", "Prepare a local path to have it's Cookbook dependencies managed by Berkshelf."
+    desc "init [PATH]", "Prepare a local path to have its Cookbook dependencies managed by Berkshelf."
     def init(path = Dir.pwd)
       if File.chef_cookbook?(path)
         options[:chefignore] = true
         options[:metadata_entry] = true
       end
 
-      generator = ::Berkshelf::InitGenerator.new([path], options)
-      generator.invoke_all
+      ::Berkshelf::InitGenerator.new([path], options).invoke_all
 
       ::Berkshelf.ui.info "Successfully initialized"
-    rescue BerkshelfError => e
-      Berkshelf.ui.fatal e
-      exit e.status_code
     end
 
     desc "version", "Display version and copyright information"
@@ -127,6 +112,39 @@ module Berkshelf
       Berkshelf.ui.info license
     end
 
+    method_option :vagrant,
+      type: :boolean,
+      desc: "Creates a Vagrantfile and dynamically change other generated files to support Vagrant"
+    method_option :git,
+      type: :boolean,
+      desc: "Creates additional git specific files if your project will be managed by git"
+    method_option :foodcritic,
+      type: :boolean,
+      desc: "Creates a Thorfile with Foodcritic support to lint test your cookbook"
+    method_option :scmversion,
+      type: :boolean,
+      desc: "Creates a Thorfile with SCMVersion support to manage versions for continuous integration"
+    method_option :no_bundler,
+      type: :boolean,
+      desc: "Skips generation of a Gemfile and other Bundler specific support"
+    method_option :license,
+      type: :string,
+      default: "reserved",
+      desc: "License for cookbook (apachev2, gplv2, gplv3, mit, reserved)",
+      aliases: "-L"
+    method_option :maintainer,
+      type: :string,
+      desc: "Name of cookbook maintainer",
+      aliases: "-m"
+    method_option :maintainer_email,
+      type: :string,
+      desc: "Email address of cookbook maintainer",
+      aliases: "-e"
+    desc "cookbook NAME", "Create a skeleton for a new cookbook"
+    def cookbook(name)
+      ::Berkshelf::CookbookGenerator.new([name, File.join(Dir.pwd, name)], options).invoke_all
+    end
+
     private
 
       def version_header

data/lib/berkshelf/cookbook_generator.rb

@@ -0,0 +1,112 @@
+module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class CookbookGenerator < BaseGenerator
+    argument :name,
+      type: :string,
+      required: true
+
+    argument :path,
+      type: :string,
+      required: true
+
+    class_option :vagrant,
+      type: :boolean,
+      default: false
+
+    class_option :git,
+      type: :boolean,
+      default: false
+
+    class_option :foodcritic,
+      type: :boolean,
+      default: false
+
+    class_option :scmversion,
+      type: :boolean,
+      default: false
+
+    class_option :no_bundler,
+      type: :boolean,
+      default: false
+
+    class_option :license,
+      type: :string,
+      default: "reserved"
+
+    class_option :maintainer,
+      type: :string,
+      default: "YOUR_NAME"
+
+    class_option :maintainer_email,
+      type: :string,
+      default: "YOUR_EMAIL"
+
+    def generate
+      empty_directory target.join("files/default")
+      empty_directory target.join("templates/default")
+      empty_directory target.join("attributes")
+      empty_directory target.join("definitions")
+      empty_directory target.join("libraries")
+      empty_directory target.join("providers")
+      empty_directory target.join("recipes")
+      empty_directory target.join("resources")
+            
+      template "default_recipe.erb", target.join("recipes/default.rb")
+      template "metadata.rb.erb", target.join("metadata.rb")
+      template license_file, target.join("LICENSE")
+      template "README.md.erb", target.join("README.md")
+
+      ::Berkshelf::InitGenerator.new([target], options.merge(default_options)).invoke_all
+    end
+
+    private
+
+      def commented(content)
+        content.split("\n").collect { |s| "# #{s}" }.join("\n")
+      end
+
+      def license_name
+        case options[:license]
+        when "apachev2"; "Apache 2.0"
+        when "gplv2"; "GNU Public License 2.0"
+        when "gplv3"; "GNU Public License 3.0"
+        when "mit"; "MIT"
+        when "reserved"; "All rights reserved"
+        else
+          raise Berkshelf::InternalError, "Unknown license: '#{options[:license]}'"
+        end
+      end
+
+      def license
+        ERB.new(File.read(File.join(self.class.source_root, license_file))).result(binding)
+      end
+
+      def license_file
+        case options[:license]
+        when "apachev2"; "licenses/apachev2.erb"
+        when "gplv2"; "licenses/gplv2.erb"
+        when "gplv3"; "licenses/gplv3.erb"
+        when "mit"; "licenses/mit.erb"
+        when "reserved"; "licenses/reserved.erb"
+        else
+          raise Berkshelf::InternalError, "Unknown license: '#{options[:license]}'"
+        end
+      end
+
+      def copyright_year
+        Time.now.year
+      end
+
+      def maintainer
+        options[:maintainer]
+      end
+
+      def maintainer_email
+        options[:maintainer_email]
+      end
+
+      def default_options
+        { metadata_entry: true, chefignore: true, cookbook_name: name }
+      end
+  end
+end