berkshelf_ext 1.0.0

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.1.0
+* Initial release

data/README.md

@@ -0,0 +1,42 @@
+# Berkshelf Ext
+
+Berkshelf extensions to add features to berkshelf not
+accepted upstream.
+
+## Usage
+
+### Via Bundler
+
+If using via `bundler`, just add an entry in the Gemfile:
+
+`gem 'berkshelf_ext'`
+
+and it will auto inject itself.
+
+### Direct
+
+Since bundler does some special loading that rubygems proper
+does not, we can't auto-inject ourselves in. Instead, just
+call the custom executable:
+
+`berks_ext`
+
+Which will add the extensions to berkshelf, and then initialize
+it as usual.
+
+## Current extensions
+
+* Resolution via nested berksfiles (nested_berksfiles)
+* Proper berksfile path when loading berksfiles (berksfile_loader_context)
+* Proper dependency resolution (dependency_chains)
+
+## Prevent extension loading
+
+You can explicitly define what is allowed or not allowed to load via
+environment variables
+
+* `BERKSHELF_EXT_EXCEPT="nested_berksfiles"`
+* `BERKSHELF_EXT_ONLY="nested_berksfiles,berksfile_loader_context"`
+
+# Info
+* Repository: https://github.com/chrisroberts/berkshelf_ext

data/berkshelf_ext.gemspec

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'berkshelf_ext/version'
+Gem::Specification.new do |s|
+  s.name = 'berkshelf_ext'
+  s.version = BerkshelfExt::VERSION.version
+  s.summary = 'Extensions for Berkshelf'
+  s.author = 'Chris Roberts'
+  s.email = 'chrisroberts.code@gmail.com'
+  s.homepage = 'http://github.com/chrisroberts/berkshelf_ext'
+  s.description = 'Extenstions for berkshelf'
+  s.require_path = 'lib'
+  s.executables = %w(berks_ext)
+  s.add_dependency 'berkshelf', BerkshelfExt::BERKSHELF_CONSTRAINT
+  s.files = Dir['**/*']
+end

data/bin/berks_ext

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'berkshelf_ext/all'
+
+begin
+  Berkshelf::Cli.start
+rescue Berkshelf::BerkshelfError => e
+  Berkshelf.ui.error e
+  Berkshelf.ui.error "\t" + e.backtrace.join("\n\t") if ENV['BERKSHELF_DEBUG']
+  exit e.status_code
+rescue Ridley::Errors::RidleyError => e
+  Berkshelf.ui.error "#{e.class} #{e}"
+  Berkshelf.ui.error "\t" + e.backtrace.join("\n\t") if ENV['BERKSHELF_DEBUG']
+  exit 47
+end

data/lib/berkshelf.rb

@@ -0,0 +1,13 @@
+require 'berkshelf_ext/version'
+
+berk_spec = Gem::Specification.find_by_name('berkshelf', BerkshelfExt::BERKSHELF_CONSTRAINT)
+
+unless(berk_spec)
+  raise "Failed to locate acceptable berkshelf version. (Constraint: #{BerkshelfExt::BERKSHELF_CONSTRAINT})"
+end
+
+berk_spec.activate_dependencies
+berk_spec.activate
+require File.join(berk_spec.full_gem_path, 'lib/berkshelf.rb')
+
+require 'berkshelf_ext/all'

data/lib/berkshelf_ext.rb

@@ -0,0 +1 @@
+require 'berkshelf_ext/version'

data/lib/berkshelf_ext/all.rb

@@ -0,0 +1,11 @@
+require 'berkshelf'
+
+Dir.glob(File.join(File.dirname(__FILE__), '*.rb')).each do |ext_file|
+  if(ENV['BERKSHELF_EXT_EXCEPT'])
+    next if ENV['BERKSHELF_EXT_EXCEPT'].split(',').include?(File.basename(ext_file).sub('.rb', ''))
+  end
+  if(ENV['BERKSHELF_EXT_ONLY'])
+    next unless ENV['BERKSHELF_EXT_ONLY'].split(',').include?(File.basename(ext_file).sub('.rb', ''))
+  end
+  require ext_file
+end

data/lib/berkshelf_ext/berksfile_loader_context.rb

@@ -0,0 +1,53 @@
+module Berkshelf
+  module BerksfileLoaderContext
+    module Berksfile
+      def self.included(klass)
+        klass.send(:include, InstanceMethods)
+        klass.send(:extend, ClassMethods)
+        klass.class_eval do
+          alias_method :non_berksfile_loader_context_load, :load
+          alias_method :load, :berksfile_loader_context_load
+          alias_method :non_berksfile_loader_context_cookbook, :cookbook
+          alias_method :cookbook, :berksfile_loader_context_cookbook
+          class << self
+            alias_method :non_berksfile_loader_context_from_file, :from_file
+            alias_method :from_file, :berksfile_loader_context_from_file
+          end
+        end
+      end
+      module InstanceMethods
+        def berksfile_loader_context_load(content, path='')
+          initial_path = Dir.pwd
+          begin
+            Dir.chdir(File.dirname(path))
+            instance_eval(content, File.expand_path(path), 1)
+          rescue => e
+            raise BerksfileReadError.new(e), "An error occurred while reading the Berksfile: #{e.to_s}"
+          ensure
+            Dir.chdir(initial_path)
+          end
+          self
+        end
+        def berksfile_loader_context_cookbook(*args)
+          if(args.last.is_a?(Hash) && args.last[:path])
+            args.last[:path] = File.expand_path(args.last[:path])
+          end
+          non_berksfile_loader_context_cookbook(*args)
+        end
+      end
+      module ClassMethods
+        def berksfile_loader_context_from_file(file)
+          begin
+            object = new(file)
+            content = File.read(file)
+            object.load(content, file.to_s)
+          rescue Errno::ENOENT => e
+            raise BerksfileNotFound, "No Berksfile or Berksfile.lock found at: #{file}"
+          end
+        end
+      end
+    end
+  end
+end
+
+Berkshelf::Berksfile.send(:include, Berkshelf::BerksfileLoaderContext::Berksfile)

data/lib/berkshelf_ext/dependency_chains.rb

@@ -0,0 +1,65 @@
+module BerkshelfExt
+  module DependencyChains
+    module Resolver
+
+      class << self
+        def included(klass)
+          klass.class_eval do
+            alias_method :non_dependency_chains_resolve, :resolve
+            alias_method :resolve, :dependency_chains_resolve
+          end
+        end
+      end
+
+      def defined_artifacts
+        Hash[*(
+            graph.artifacts.map do |art|
+              [art.name, art]
+            end
+        ).flatten]
+      end
+      
+      def chain_dependencies!
+        defined_artifacts.each do |name, artifact|
+          @sources[name].cached_cookbook.dependencies.each do |dep|
+            dep << ">= 0.0.0" unless dep.size > 1
+            artifact.depends(dep.first, dep.last)
+          end
+        end
+      end
+
+      def dependency_chains_resolve(demands = nil)
+        demands = Array(demands) unless demands.is_a?(Array)
+        if(demands.empty?)
+          demands = [].tap do |l_demands|
+            graph.artifacts.each do |artifact|
+              l_demands << [artifact.name, artifact.version]
+            end
+          end
+        end
+        unless(@skip_dependencies)
+          chain_dependencies!
+        end
+        # since we only get an error if the graph does not contain a
+        # solution and not the dependency that caused the failure, run
+        # each dependency through the graph individually so we can
+        # provide a useful error string
+        demands.each do |demand|
+          begin
+            solution = Solve.it!(graph, [demand])
+          rescue Solve::Errors::NoSolutionError
+            raise Berkshelf::NoSolution.new("Failed to resolve dependencies for: #{demand.join(': ')}")
+          end
+        end
+        solution = Solve.it!(graph, demands)
+        [].tap do |cached_cookbooks|
+          solution.each do |name, version|
+            cached_cookbooks << get_source(name).cached_cookbook
+          end
+        end
+      end
+    end
+  end
+end
+
+Berkshelf::Resolver.send(:include, BerkshelfExt::DependencyChains::Resolver)

data/lib/berkshelf_ext/nested_berksfiles.rb

@@ -0,0 +1,82 @@
+module BerkshelfExt
+  module NestedBerksfiles
+    module Cli
+      class << self
+        def included(klass)
+          klass.tasks['upload'].options[:nested_berksfiles] = Thor::Option.new(
+            'nested_berksfiles', :type => :boolean, :default => false,
+            :desc => 'Use Berksfiles found within cookbooks specifed in Berksfile'
+          )
+        end
+      end
+    end
+
+    module Berksfile
+      class << self
+        def included(klass)
+          klass.class_eval do
+            alias_method :non_nested_berksfiles_resolver, :resolver
+            alias_method :resolver, :nested_berksfiles_resolver
+          end
+        end
+      end
+      
+      def nested_berksfiles_resolver(options={})
+        Berkshelf::Resolver.new(
+          self.downloader,
+          sources: sources(options),
+          skip_dependencies: options[:skip_dependencies],
+          nested_berksfiles: options[:nested_berksfiles]
+        )
+      end
+    end
+
+    module Resolver
+
+      class << self
+        def included(klass)
+          klass.class_eval do
+            alias_method :non_nested_berksfiles_initialize, :initialize
+            alias_method :initialize, :nested_berksfiles_initialize
+          end
+        end
+      end
+      
+      def nested_berksfiles_initialize(downloader, options={})
+        skip_deps = options[:skip_dependencies]
+        options[:skip_dependencies] = true
+        non_nested_berksfiles_initialize(downloader, options)
+        @skip_dependencies = options[:skip_dependencies] = skip_deps
+        if(options[:nested_berksfiles])
+          process_nested_berksfiles(options[:sources])
+        end
+        unless(options[:skip_dependencies])
+          @sources.values.each do |source|
+            add_source_dependencies(source)
+          end
+        end
+      end
+
+      def process_nested_berksfiles(srcs)
+        srcs.map(&:name).each do |name|
+          berks_path = File.join(@sources[name].cached_cookbook.path, 'Berksfile')
+          if(File.exists?(berks_path))
+            berksfile = Berkshelf::Berksfile.from_file(berks_path)
+            new_sources = berksfile.sources.delete_if do |new_src|
+              @sources.has_key?(new_src.name)
+            end
+            new_sources.each do |source|
+              add_source(source, false)
+            end
+            process_nested_berksfiles(new_sources)
+          end
+        end
+      end
+
+    end
+  end
+end
+
+Berkshelf::Cli.send(:include, BerkshelfExt::NestedBerksfiles::Cli)
+Berkshelf::Berksfile.send(:include, BerkshelfExt::NestedBerksfiles::Berksfile)
+Berkshelf::Resolver.send(:include, BerkshelfExt::NestedBerksfiles::Resolver)

data/lib/berkshelf_ext/version.rb

@@ -0,0 +1,7 @@
+module BerkshelfExt
+  class Version < Gem::Version
+  end
+
+  VERSION = Version.new('1.0.0')
+  BERKSHELF_CONSTRAINT = '~> 1.3.1'
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: berkshelf_ext
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: berkshelf
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+description: Extenstions for berkshelf
+email: chrisroberts.code@gmail.com
+executables:
+- berks_ext
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/berkshelf.rb
+- lib/berkshelf_ext/all.rb
+- lib/berkshelf_ext/nested_berksfiles.rb
+- lib/berkshelf_ext/version.rb
+- lib/berkshelf_ext/dependency_chains.rb
+- lib/berkshelf_ext/berksfile_loader_context.rb
+- lib/berkshelf_ext.rb
+- README.md
+- berkshelf_ext.gemspec
+- bin/berks_ext
+- berkshelf_ext-1.0.0.gem
+- CHANGELOG.md
+homepage: http://github.com/chrisroberts/berkshelf_ext
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Extensions for Berkshelf
+test_files: []
+has_rdoc: