berkshelf 1.2.0.rc1 → 1.2.1

data/lib/berkshelf/chef/cookbook/syntax_check.rb

@@ -1,158 +0,0 @@
-module Berkshelf::Chef::Cookbook
-  # Encapsulates the process of validating the ruby syntax of files in Chef
-  # cookbooks.
-  #
-  # Borrowed and modified from: {https://github.com/opscode/chef/blob/11.4.0/lib/chef/cookbook/syntax_check.rb}
-  #
-  # Copyright:: Copyright (c) 2010 Opscode, Inc.
-  #
-  # Licensed under the Apache License, Version 2.0 (the "License");
-  # you may not use this file except in compliance with the License.
-  # You may obtain a copy of the License at
-  # 
-  #     http://www.apache.org/licenses/LICENSE-2.0
-  # 
-  # Unless required by applicable law or agreed to in writing, software
-  # distributed under the License is distributed on an "AS IS" BASIS,
-  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  # See the License for the specific language governing permissions and
-  # limitations under the License.
-  class SyntaxCheck
-    # Implements set behavior with disk-based persistence. Objects in the set
-    # are expected to be strings containing only characters that are valid in
-    # filenames.
-    #
-    # This class is used to track which files have been syntax checked so
-    # that known good files are not rechecked.
-    class PersistentSet
-      attr_reader :cache_path
-
-      # Create a new PersistentSet. Values in the set are persisted by
-      # creating a file in the +cache_path+ directory. If not given, the
-      # value of Chef::Config[:syntax_check_cache_path] is used; if that
-      # value is not configured, the value of
-      # Chef::Config[:cache_options][:path] is used.
-      #--
-      # history: prior to Chef 11, the cache implementation was based on
-      # moneta and configured via cache_options[:path]. Knife configs
-      # generated with Chef 11 will have `syntax_check_cache_path`, but older
-      # configs will have `cache_options[:path]`. `cache_options` is marked
-      # deprecated in chef/config.rb but doesn't currently trigger a warning.
-      # See also: CHEF-3715
-      def initialize(cache_path = nil)
-        @cache_path = cache_path || Berkshelf::Chef::Config[:syntax_check_cache_path] ||
-          Berkshelf::Chef::Config[:cache_options][:path]
-        @cache_path_created = false
-      end
-
-      # Adds +value+ to the set's collection.
-      def add(value)
-        ensure_cache_path_created
-        FileUtils.touch(File.join(cache_path, value))
-      end
-
-      # Returns true if the set includes +value+
-      def include?(value)
-        File.exist?(File.join(cache_path, value))
-      end
-
-      private
-
-        def ensure_cache_path_created
-          return true if @cache_path_created
-          FileUtils.mkdir_p(cache_path)
-          @cache_path_created = true
-        end
-    end
-
-    include Berkshelf::Mixin::ShellOut
-    include Berkshelf::Mixin::Checksum
-
-    attr_reader :cookbook_path
-
-    # A PersistentSet object that tracks which files have already been
-    # validated.
-    attr_reader :validated_files
-
-    # Create a new SyntaxCheck object
-    #
-    # @param [String] cookbook_path
-    #   the (on disk) path to the cookbook
-    def initialize(cookbook_path)
-      @cookbook_path   = cookbook_path
-      @validated_files = PersistentSet.new
-    end
-
-    def ruby_files
-      Dir[File.join(cookbook_path, '**', '*.rb')]
-    end
-
-    def untested_ruby_files
-      ruby_files.reject do |file|
-        if validated?(file)
-          true
-        else
-          false
-        end
-      end
-    end
-
-    def template_files
-      Dir[File.join(cookbook_path, '**', '*.erb')]
-    end
-
-    def untested_template_files
-      template_files.reject do |file| 
-        if validated?(file)
-          true
-        else
-          false
-        end
-      end
-    end
-
-    def validated?(file)
-      validated_files.include?(checksum(file))
-    end
-
-    def validated(file)
-      validated_files.add(checksum(file))
-    end
-
-    def validate_ruby_files
-      untested_ruby_files.each do |ruby_file|
-        return false unless validate_ruby_file(ruby_file)
-        validated(ruby_file)
-      end
-    end
-
-    def validate_templates
-      untested_template_files.each do |template|
-        return false unless validate_template(template)
-        validated(template)
-      end
-    end
-
-    def validate_template(erb_file)
-      result = shell_out("erubis -x #{erb_file} | ruby -c")
-      result.error!
-      true
-    rescue Mixlib::ShellOut::ShellCommandFailed
-      file_relative_path = erb_file[/^#{Regexp.escape(cookbook_path+File::Separator)}(.*)/, 1]
-      Berkshelf.ui.error("Erb template #{file_relative_path} has a syntax error:")
-      result.stderr.each_line { |l| Chef::Log.fatal(l.chomp) }
-      false
-    end
-
-    def validate_ruby_file(ruby_file)
-      result = shell_out("ruby -c #{ruby_file}")
-      result.error!
-      true
-    rescue Mixlib::ShellOut::ShellCommandFailed
-      file_relative_path = ruby_file[/^#{Regexp.escape(cookbook_path+File::Separator)}(.*)/, 1]
-      Berkshelf.ui.error("Cookbook file #{file_relative_path} has a ruby syntax error:")
-      result.stderr.each_line { |l| Berkshelf.ui.error(l.chomp) }
-      false
-    end
-  end
-end

data/lib/berkshelf/chef/digester.rb

@@ -1,67 +0,0 @@
-require 'digest'
-
-module Berkshelf::Chef
-  # Borrowed and modified from: {https://github.com/opscode/chef/blob/11.4.0/lib/chef/digester.rb}
-  #
-  # Copyright:: Copyright (c) 2009 Opscode, Inc.
-  #
-  # Licensed under the Apache License, Version 2.0 (the "License");
-  # you may not use this file except in compliance with the License.
-  # You may obtain a copy of the License at
-  #
-  #     http://www.apache.org/licenses/LICENSE-2.0
-  #
-  # Unless required by applicable law or agreed to in writing, software
-  # distributed under the License is distributed on an "AS IS" BASIS,
-  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  # See the License for the specific language governing permissions and
-  # limitations under the License.
-  class Digester
-    class << self
-      def instance
-        @instance ||= new
-      end
-
-      def checksum_for_file(*args)
-        instance.checksum_for_file(*args)
-      end
-
-      def md5_checksum_for_file(*args)
-        instance.generate_md5_checksum_for_file(*args)
-      end
-    end
-
-    def validate_checksum(*args)
-      self.class.validate_checksum(*args)
-    end
-
-    def checksum_for_file(file)
-      generate_checksum(file)
-    end
-
-    def generate_checksum(file)
-      checksum_file(file, Digest::SHA256.new)
-    end
-
-    def generate_md5_checksum_for_file(file)
-      checksum_file(file, Digest::MD5.new)
-    end
-
-    def generate_md5_checksum(io)
-      checksum_io(io, Digest::MD5.new)
-    end
-
-    private
-
-      def checksum_file(file, digest)
-        File.open(file, 'rb') { |f| checksum_io(f, digest) }
-      end
-
-      def checksum_io(io, digest)
-        while chunk = io.read(1024 * 8)
-          digest.update(chunk)
-        end
-        digest.hexdigest
-      end
-  end
-end

data/lib/berkshelf/mixin/checksum.rb

@@ -1,16 +0,0 @@
-require 'berkshelf/chef'
-
-module Berkshelf::Mixin
-  # @author Jamie Winsor <reset@riotgames.com>
-  #
-  # Inspired by and dependency-free replacement for
-  # {https://github.com/opscode/chef/blob/11.4.0/lib/chef/mixin/checksum.rb}
-  module Checksum
-    # @param [String] file
-    #
-    # @return [String]
-    def checksum(file)
-      Berkshelf::Chef::Digester.checksum_for_file(file)
-    end
-  end
-end

data/lib/berkshelf/mixin/params_validate.rb

@@ -1,218 +0,0 @@
-module Berkshelf::Mixin
-  # Borrowed and modified from: {https://raw.github.com/opscode/chef/11.4.0/lib/chef/mixin/params_validate.rb}
-  #
-  # Copyright:: Copyright (c) 2008 Opscode, Inc.
-  #
-  # Licensed under the Apache License, Version 2.0 (the "License");
-  # you may not use this file except in compliance with the License.
-  # You may obtain a copy of the License at
-  # 
-  #     http://www.apache.org/licenses/LICENSE-2.0
-  # 
-  # Unless required by applicable law or agreed to in writing, software
-  # distributed under the License is distributed on an "AS IS" BASIS,
-  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  # See the License for the specific language governing permissions and
-  # limitations under the License.
-  module ParamsValidate
-    # Takes a hash of options, along with a map to validate them.  Returns the original
-    # options hash, plus any changes that might have been made (through things like setting
-    # default values in the validation map)
-    #
-    # For example:
-    #
-    #   validate({ :one => "neat" }, { :one => { :kind_of => String }})
-    # 
-    # Would raise an exception if the value of :one above is not a kind_of? string.  Valid
-    # map options are:
-    #
-    # :default:: Sets the default value for this parameter.
-    # :callbacks:: Takes a hash of Procs, which should return true if the argument is valid.  
-    #              The key will be inserted into the error message if the Proc does not return true:
-    #                 "Option #{key}'s value #{value} #{message}!"
-    # :kind_of:: Ensure that the value is a kind_of?(Whatever).  If passed an array, it will ensure 
-    #            that the value is one of those types.
-    # :respond_to:: Ensure that the value has a given method.  Takes one method name or an array of
-    #               method names.
-    # :required:: Raise an exception if this parameter is missing. Valid values are true or false, 
-    #             by default, options are not required.
-    # :regex:: Match the value of the paramater against a regular expression.
-    # :equal_to:: Match the value of the paramater with ==.  An array means it can be equal to any
-    #             of the values.
-    def validate(opts, map)
-      #--
-      # validate works by taking the keys in the validation map, assuming it's a hash, and
-      # looking for _pv_:symbol as methods.  Assuming it find them, it calls the right 
-      # one.  
-      #++
-      raise ArgumentError, "Options must be a hash" unless opts.kind_of?(Hash)
-      raise ArgumentError, "Validation Map must be a hash" unless map.kind_of?(Hash)   
-      
-      map.each do |key, validation|
-        unless key.kind_of?(Symbol) || key.kind_of?(String)
-          raise ArgumentError, "Validation map keys must be symbols or strings!"
-        end
-        case validation
-        when true
-          _pv_required(opts, key)
-        when false
-          true
-        when Hash
-          validation.each do |check, carg|
-            check_method = "_pv_#{check.to_s}"
-            if self.respond_to?(check_method, true)
-              self.send(check_method, opts, key, carg)
-            else
-              raise ArgumentError, "Validation map has unknown check: #{check}"
-            end
-          end
-        end
-      end
-      opts
-    end
-        
-    def set_or_return(symbol, arg, validation)
-      iv_symbol = "@#{symbol.to_s}".to_sym
-      map = {
-        symbol => validation
-      }
-
-      if arg == nil && self.instance_variable_defined?(iv_symbol) == true
-        self.instance_variable_get(iv_symbol)
-      else
-        opts = validate({ symbol => arg }, { symbol => validation })
-        self.instance_variable_set(iv_symbol, opts[symbol])
-      end
-    end
-          
-    private
-    
-      # Return the value of a parameter, or nil if it doesn't exist.
-      def _pv_opts_lookup(opts, key)
-        if opts.has_key?(key.to_s)
-          opts[key.to_s]
-        elsif opts.has_key?(key.to_sym)
-          opts[key.to_sym]
-        else
-          nil
-        end
-      end
-      
-      # Raise an exception if the parameter is not found.
-      def _pv_required(opts, key, is_required=true)
-        if is_required
-          if (opts.has_key?(key.to_s) && !opts[key.to_s].nil?) ||
-              (opts.has_key?(key.to_sym) && !opts[key.to_sym].nil?)
-            true
-          else
-            raise ValidationFailed, "Required argument #{key} is missing!"
-          end
-        end
-      end
-      
-      def _pv_equal_to(opts, key, to_be)
-        value = _pv_opts_lookup(opts, key)
-        unless value.nil?
-          passes = false
-          Array(to_be).each do |tb|
-            passes = true if value == tb
-          end
-          unless passes
-            raise ValidationFailed, "Option #{key} must be equal to one of: #{to_be.join(", ")}!  You passed #{value.inspect}."
-          end
-        end
-      end
-      
-      # Raise an exception if the parameter is not a kind_of?(to_be)
-      def _pv_kind_of(opts, key, to_be)
-        value = _pv_opts_lookup(opts, key)
-        unless value.nil?
-          passes = false
-          Array(to_be).each do |tb|
-            passes = true if value.kind_of?(tb)
-          end
-          unless passes
-            raise ValidationFailed, "Option #{key} must be a kind of #{to_be}!  You passed #{value.inspect}."
-          end
-        end
-      end
-      
-      # Raise an exception if the parameter does not respond to a given set of methods.
-      def _pv_respond_to(opts, key, method_name_list)
-        value = _pv_opts_lookup(opts, key)
-        unless value.nil?
-          Array(method_name_list).each do |method_name|
-            unless value.respond_to?(method_name)
-              raise ValidationFailed, "Option #{key} must have a #{method_name} method!"
-            end
-          end
-        end
-      end
-
-      # Assert that parameter returns false when passed a predicate method.
-      # For example, :cannot_be => :blank will raise a ValidationFailed
-      # error value.blank? returns a 'truthy' (not nil or false) value.
-      #
-      # Note, this will *PASS* if the object doesn't respond to the method.
-      # So, to make sure a value is not nil and not blank, you need to do
-      # both :cannot_be => :blank *and* :cannot_be => :nil (or :required => true)
-      def _pv_cannot_be(opts, key, predicate_method_base_name)
-        value = _pv_opts_lookup(opts, key)
-        predicate_method = (predicate_method_base_name.to_s + "?").to_sym
-
-        if value.respond_to?(predicate_method)
-          if value.send(predicate_method)
-            raise ValidationFailed, "Option #{key} cannot be #{predicate_method_base_name}"
-          end
-        end
-      end
-    
-      # Assign a default value to a parameter.
-      def _pv_default(opts, key, default_value)
-        value = _pv_opts_lookup(opts, key)
-        if value == nil
-          opts[key] = default_value
-        end
-      end
-      
-      # Check a parameter against a regular expression.
-      def _pv_regex(opts, key, regex)
-        value = _pv_opts_lookup(opts, key)
-        if value != nil
-          passes = false
-          [ regex ].flatten.each do |r|
-            if value != nil
-              if r.match(value.to_s)
-                passes = true
-              end
-            end
-          end
-          unless passes
-            raise ValidationFailed, "Option #{key}'s value #{value} does not match regular expression #{regex.inspect}"
-          end
-        end
-      end
-      
-      # Check a parameter against a hash of proc's.
-      def _pv_callbacks(opts, key, callbacks)
-        raise ArgumentError, "Callback list must be a hash!" unless callbacks.kind_of?(Hash)
-        value = _pv_opts_lookup(opts, key)
-        if value != nil
-          callbacks.each do |message, zeproc|
-            if zeproc.call(value) != true
-              raise ValidationFailed, "Option #{key}'s value #{value} #{message}!"
-            end
-          end
-        end
-      end
-
-      # Allow a parameter to default to @name
-      def _pv_name_attribute(opts, key, is_name_attribute=true)
-        if is_name_attribute
-          if opts[key] == nil
-            opts[key] = self.instance_variable_get("@name")
-          end
-        end
-      end
-  end
-end