librarian 0.0.20 → 0.0.21

data/lib/librarian/chef/manifest.rb

@@ -1,43 +0,0 @@
-require 'json'
-require 'yaml'
-
-require 'librarian/manifest'
-
-module Librarian
-  module Chef
-    class Manifest < Manifest
-
-      module Helpers
-
-        MANIFESTS = %w(metadata.json metadata.yml metadata.yaml metadata.rb)
-
-        def manifest_path(path)
-          MANIFESTS.map{|s| path.join(s)}.find{|s| s.exist?}
-        end
-
-        def read_manifest(name, manifest_path)
-          case manifest_path.extname
-          when ".json" then JSON.parse(manifest_path.read)
-          when ".yml", ".yaml" then YAML.load(manifest_path.read)
-          when ".rb" then compile_manifest(name, manifest_path.dirname)
-          end
-        end
-
-        def compile_manifest(name, path)
-          # Inefficient, if there are many cookbooks with uncompiled metadata.
-          require 'chef/json_compat'
-          require 'chef/cookbook/metadata'
-          md = ::Chef::Cookbook::Metadata.new
-          md.name(name)
-          md.from_file(path.join('metadata.rb').to_s)
-          JSON.parse(::Chef::JSONCompat.to_json_pretty(md))
-        end
-
-      end
-
-      include Helpers
-      extend Helpers
-
-    end
-  end
-end

data/lib/librarian/chef/source/local/manifest.rb

@@ -1,82 +0,0 @@
-require 'fileutils'
-require 'pathname'
-
-require 'librarian/chef/manifest'
-
-module Librarian
-  module Chef
-    module Source
-      module Local
-        class Manifest < Manifest
-
-          class << self
-
-            def create(source, dependency, path)
-              new(source, dependency.name, path)
-            end
-
-            def manifest?(dependency, path)
-              path = Pathname.new(path)
-              !!manifest_path(path)
-            end
-
-            def check_manifest(dependency, manifest_path)
-              manifest = read_manifest(dependency.name, manifest_path)
-              manifest["name"] == dependency.name
-            end
-
-          end
-
-          attr_reader :path
-
-          def initialize(source, name, path)
-            super(source, name)
-            @path = Pathname.new(path)
-            @found_path = nil
-          end
-
-          def found_path
-            @found_path ||= source.manifest_search_paths(self).find{|p| self.class.manifest?(self, p)}
-          end
-
-          def manifest
-            @manifest ||= fetch_manifest!
-          end
-
-          def fetch_manifest!
-            expect_manifest
-
-            read_manifest(name, manifest_path(found_path))
-          end
-
-          def fetch_version!
-            manifest['version']
-          end
-
-          def fetch_dependencies!
-            manifest['dependencies']
-          end
-
-          def install!
-            debug { "Installing #{name}-#{version}" }
-            install_path = environment.install_path.join(name)
-            if install_path.exist?
-              debug { "Deleting #{relative_path_to(install_path)}" }
-              install_path.rmtree
-            end
-            debug { "Copying #{relative_path_to(found_path)} to #{relative_path_to(install_path)}" }
-            FileUtils.cp_r(found_path, install_path)
-          end
-
-        private
-
-          def expect_manifest
-            return if found_path && manifest_path(found_path)
-            raise Error, "No metadata file found for #{name} from #{source}! If this should be a cookbook, you might consider contributing a metadata file upstream or forking the cookbook to add your own metadata file."
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/librarian/chef/source/site/manifest.rb

@@ -1,94 +0,0 @@
-require "fileutils"
-
-require "json"
-
-require "librarian/dependency"
-require 'librarian/chef/manifest'
-
-module Librarian
-  module Chef
-    module Source
-      class Site
-        class Manifest < Manifest
-
-          attr_reader :version_uri
-          attr_reader :install_path
-
-          def initialize(source, name, version_uri = nil)
-            super(source, name)
-            @version_uri = version_uri
-
-            @cache_path = nil
-            @metadata_cache_path = nil
-            @package_cache_path = nil
-            @install_path = environment.install_path.join(name)
-
-            @version_metadata = nil
-            @version_manifest = nil
-          end
-
-          def fetch_version!
-            version_metadata['version']
-          end
-
-          def fetch_dependencies!
-            version_manifest['dependencies'].map{|k, v| Dependency.new(k, v, nil)}
-          end
-
-          def version_uri
-            @version_uri ||= begin
-              source.cache!([self])
-              source.manifests(self).find{|m| m.version == version}.version_uri
-            end
-          end
-
-          def version_uri=(version_uri)
-            @version_uri = version_uri
-          end
-
-          def cache_path
-            @cache_path ||= source.version_cache_path(self, version_uri)
-          end
-          def metadata_cache_path
-            @metadata_cache_path ||= cache_path.join('version.json')
-          end
-          def package_cache_path
-            @package_cache_path ||= cache_path.join('package')
-          end
-
-          def version_metadata
-            @version_metadata ||= fetch_version_metadata!
-          end
-
-          def fetch_version_metadata!
-            source.cache_version_metadata!(self, version_uri)
-            JSON.parse(metadata_cache_path.read)
-          end
-
-          def version_manifest
-            @version_manifest ||= fetch_version_manifest!
-          end
-
-          def fetch_version_manifest!
-            source.cache_version_package!(self, version_uri, version_metadata['file'])
-            manifest_path = manifest_path(package_cache_path)
-            read_manifest(name, manifest_path)
-          end
-
-          def install!
-            debug { "Installing #{self}" }
-            version_manifest # make sure it's cached
-            if install_path.exist?
-              debug { "Deleting #{relative_path_to(install_path)}" }
-              install_path.rmtree
-            end
-            package_cache_path = source.version_package_cache_path(self, version_uri)
-            debug { "Copying #{relative_path_to(package_cache_path)} to #{relative_path_to(install_path)}" }
-            FileUtils.cp_r(package_cache_path, install_path)
-          end
-
-        end
-      end
-    end
-  end
-end