halite 1.0.0.rc.1

data/lib/halite/berkshelf/source.rb

@@ -0,0 +1,56 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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.
+#
+
+require 'halite/gem'
+require 'berkshelf/source'
+require 'berkshelf/api_client/remote_cookbook'
+
+module Halite
+  module Berkshelf
+
+    class Source < ::Berkshelf::Source
+      def initialize
+        super 'https://supermarket.chef.io'
+      end
+
+      def build_universe
+        # Scan all gems
+        ::Gem::Specification.stubs.map do |spec|
+          Gem.new(spec)
+        end.select do |cook|
+          cook.is_halite_cookbook?
+        end.map do |cook|
+          # Build a fake "remote" cookbook
+          ::Berkshelf::APIClient::RemoteCookbook.new(
+            cook.cookbook_name,
+            cook.version,
+            {
+              location_type: 'halite',
+              location_path: cook.name,
+              dependencies: cook.cookbook_dependencies.inject({}) {|memo, dep| memo[dep.name] = dep.requirement; memo },
+            },
+          )
+        end
+      end
+
+      def to_s
+        "Halite gems"
+      end
+      alias :uri :to_s
+    end
+
+  end
+end

data/lib/halite/converter.rb

@@ -0,0 +1,17 @@
+require 'halite/converter/libraries'
+require 'halite/converter/metadata'
+require 'halite/converter/other'
+require 'halite/converter/readme'
+
+module Halite
+  module Converter
+
+    def self.write(spec, base_path)
+      Metadata.write(spec, base_path)
+      Libraries.write(spec, base_path)
+      Other.write(spec, base_path)
+      Readme.write(spec, base_path)
+    end
+
+  end
+end

data/lib/halite/converter/libraries.rb

@@ -0,0 +1,40 @@
+module Halite
+  module Converter
+    module Libraries
+
+      # Chef doesn't allow subfolders under libraries/ currently
+      def self.flatten_filename(path)
+        path.gsub(/\//, '__')
+      end
+
+      def self.generate(spec, data, entry_point=false)
+        # No newline on the header so that line numbers in the files aren't changed.
+        buf = (entry_point ? "ENV['HALITE_LOAD'] = '1'; begin; " : "if ENV['HALITE_LOAD']; ")
+        # Rewrite requires to require_relative as needed.
+        data = data.gsub(/require ['"](#{spec.name}[^'"]*)['"]/) { "require_relative '#{flatten_filename($1)}'" }
+        spec.cookbook_dependencies.each do |dep|
+          next unless dep.type == :dependencies
+          # This is kind of gross, but not sure what else to do
+          data = data.gsub(/require ['"](#{dep.name}[^'"]*)['"]/) { "require_relative '../../#{dep.name}/libraries/#{flatten_filename($1)}'" }
+        end
+        buf << data.rstrip
+        # Match up with the header. All files get one line longer. ¯\_(ツ)_/¯
+        buf << (entry_point ? "\nensure; ENV.delete('HALITE_LOAD'); end\n" : "\nend\n")
+        buf
+      end
+
+      def self.write(spec, base_path, entry_point_name=nil)
+        entry_point_name ||= spec.name
+        # Handle both cases, with .rb and without
+        entry_point_name += '.rb' unless entry_point_name.end_with?('.rb')
+        lib_path = File.join(base_path, 'libraries')
+        # Create cookbook's libraries folder
+        Dir.mkdir(lib_path) unless File.directory?(lib_path)
+        spec.each_library_file do |path, rel_path|
+          IO.write(File.join(lib_path, flatten_filename(rel_path)), generate(spec, IO.read(path), entry_point_name == rel_path))
+        end
+      end
+
+    end
+  end
+end

data/lib/halite/converter/metadata.rb

@@ -0,0 +1,21 @@
+module Halite
+  module Converter
+    module Metadata
+
+      def self.generate(spec)
+        buf = spec.license_header
+        buf << "name #{spec.cookbook_name.inspect}\n"
+        buf << "version #{spec.version.inspect}\n"
+        spec.cookbook_dependencies.each do |dep|
+          buf << "depends #{dep.name.inspect}, #{dep.requirement.inspect}\n"
+        end
+        buf
+      end
+
+      def self.write(spec, base_path)
+        IO.write(File.join(base_path, 'metadata.rb'), generate(spec))
+      end
+
+    end
+  end
+end

data/lib/halite/converter/other.rb

@@ -0,0 +1,19 @@
+module Halite
+  module Converter
+    module Other
+
+      def self.write(spec, base_path)
+        spec.each_file('chef') do |path, rel_path|
+          dir_path = File.dirname(rel_path)
+          FileUtils.mkdir_p(File.join(base_path, dir_path)) unless dir_path == '.'
+          File.open(path, 'rb') do |in_f|
+            File.open(File.join(base_path, rel_path), 'wb') do |out_f|
+              IO.copy_stream(in_f, out_f)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/halite/converter/readme.rb

@@ -0,0 +1,20 @@
+module Halite
+  module Converter
+    module Readme
+
+      def self.write(spec, base_path)
+        readme_path = %w{README.md README README.txt readme.md readme readme.txt}.map do |name|
+          File.join(spec.full_gem_path, name)
+        end.find {|path| File.exists?(path) }
+        if readme_path
+          File.open(readme_path, 'rb') do |in_f|
+            File.open(File.join(base_path, File.basename(readme_path)), 'wb') do |out_f|
+              IO.copy_stream(in_f, out_f)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/halite/dependencies.rb

@@ -0,0 +1,72 @@
+require 'halite/error'
+
+module Halite
+  module Dependencies
+    class InvalidDependencyError < Error; end
+
+    Dependency = Struct.new(:name, :requirement, :type)
+
+    def self.extract(spec)
+      deps = []
+      deps += clean_and_tag(extract_from_requirements(spec), :requirements)
+      deps += clean_and_tag(extract_from_metadata(spec), :metadata)
+      deps += clean_and_tag(extract_from_dependencies(spec), :dependencies)
+      deps
+    end
+
+    def self.extract_from_requirements(spec)
+      # Simple dependencies in the requirements array.
+      spec.requirements
+    end
+
+    def self.extract_from_metadata(spec)
+      # This will only work on Rubygems 2.0 or higher I think, gee thats just too bad.
+      # The metadata can only be a single string, so split on comma.
+      spec.metadata.fetch('halite_dependencies', '').split(/,/)
+    end
+
+    def self.extract_from_dependencies(spec)
+      # Find any gem dependencies that are cookbooks in disguise.
+      spec.dependencies.select do |dep|
+        Gem.new(dep).is_halite_cookbook?
+      end.map do |dep|
+        [Gem.new(dep).cookbook_name] + dep.requirements_list
+      end
+    end
+
+    def self.clean_and_tag(deps, tag)
+      deps.map do |dep|
+        dep = clean(dep)
+        Dependency.new(dep[0], dep[1], tag)
+      end
+    end
+
+
+    def self.clean(dep)
+      # Convert to an array of strings
+      dep = Array(dep).map {|obj| obj.to_s.strip }
+      # Unpack single strings like 'foo >= 1.0'
+      dep = dep.first.split(/\s+/, 2) if dep.length == 1
+      # Default version constraint to match rubygems behavior when sourcing from simple strings
+      dep << '>= 0' if dep.length == 1
+      raise InvalidDependencyError.new("Chef only supports a single version constraint on each dependency: #{dep}") if dep.length > 2 # ಠ_ಠ
+      dep[1] = clean_requirement(dep[1])
+      dep
+    end
+
+    def self.clean_requirement(req)
+      req = ::Gem::Requirement.create(req)
+      req.requirements[0][1] = clean_version(req.requirements[0][1])
+      req.to_s
+    end
+
+    def self.clean_version(ver)
+      segments = ver.segments
+      # Various ways Chef differs from Rubygems
+      raise InvalidDependencyError.new("Chef only supports two or three version segments: #{ver}") if segments.length < 1 || segments.length > 3
+      segments.each {|s| raise InvalidDependencyError.new("Chef does not support pre-release version numbers: #{ver}") unless s.is_a?(Integer) }
+      segments << 0 if segments.length == 1
+      ::Gem::Version.new(segments.join('.'))
+    end
+  end
+end

data/lib/halite/error.rb

@@ -0,0 +1,4 @@
+module Halite
+  class Error < ::Exception
+  end
+end

data/lib/halite/gem.rb

@@ -0,0 +1,82 @@
+require 'halite/dependencies'
+
+module Halite
+  class Gem
+    # name can be either a string name, Gem::Dependency, or Gem::Specification
+    def initialize(name, version=nil)
+      name = name.to_spec if name.is_a?(::Gem::Dependency) # Allow passing either
+      if name.is_a?(::Gem::Specification)
+        raise Error.new("Cannot pass version when using an explicit specficiation") if version
+        @spec = name
+        @name = spec.name
+      else
+        @name = name
+        @version = version
+        raise Error.new("Gem #{name}#{version ? " v#{version}" : ''} not found") unless spec
+      end
+    end
+
+    def spec
+      @spec ||= ::Gem::Dependency.new(@name, ::Gem::Requirement.new(@version)).to_spec
+    end
+
+    def method_missing(*args)
+      spec.send(*args)
+    end
+
+    def version
+      spec.version.to_s
+    end
+
+    def cookbook_name
+      if spec.metadata.include?('halite_name')
+        spec.metadata['halite_name']
+      else
+        spec.name.gsub(/(^(chef|cookbook)[_-])|([_-](chef|cookbook))$/, '')
+      end
+    end
+
+    # The Rubygems API is shit and just assumes the file layout
+    def spec_file
+      File.join(spec.full_gem_path, spec.name + '.gemspec')
+    end
+
+    def license_header
+      IO.readlines(spec_file).take_while { |line| line.strip.empty? || line.strip.start_with?('#') }.join('')
+    end
+
+    def each_file(prefix_paths=nil, &block)
+      files = []
+      spec.files.each do |path|
+        prefix = if prefix_paths
+          Array(prefix_paths).map {|p| p.end_with?('/') ? p : p + '/' }.find {|p| path.start_with?(p) }
+        else
+          ''
+        end
+        next unless prefix # No match
+        value = [
+          File.join(spec.full_gem_path, path), # Full path
+          path[prefix.length..-1], # Relative path
+        ]
+        files << value
+        block.call(*value) if block
+      end
+      files.sort! # To be safe
+    end
+
+    # Special case of the above using spec's require paths
+    def each_library_file(&block)
+      each_file(spec.require_paths, &block)
+    end
+
+    def cookbook_dependencies
+      @cookbook_dependencies ||= Dependencies.extract(spec)
+    end
+
+    # Is this gem really a cookbook? (anything that depends directly on halite and doesn't have the ignore flag)
+    def is_halite_cookbook?
+      spec.dependencies.any? {|subdep| subdep.name == 'halite'} && !spec.metadata.include?('halite_ignore')
+    end
+
+  end
+end

data/lib/halite/rake_helper.rb

@@ -0,0 +1,151 @@
+# Much inspiration from Bundler's GemHelper. Thanks!
+require 'tmpdir'
+require 'thor/shell'
+
+require 'halite'
+require 'halite/error'
+
+module Halite
+  class RakeHelper
+    include Rake::DSL if defined? Rake::DSL
+
+    def self.install_tasks(*args)
+      new(*args).install
+    end
+
+    attr_accessor :gem_name, :base, :cookbook_name
+
+    def initialize(gem_name=nil, base=nil, no_gem=nil, no_foodcritic=nil, no_kitchen=nil)
+      if gem_name.is_a?(Hash)
+        opts = gem_name.inject({}) {|memo, (key, value)| memo[key.to_s] = value; memo }
+        gem_name = opts['gem_name']
+        base = opts['base']
+        no_gem = opts['no_gem']
+        no_foodcritic = opts['no_foodcritic']
+        no_kitchen = opts['no_kitchen']
+      end
+      # Order is important, find_gem_name needs base to be set
+      @base = base || if defined? Rake
+        Rake.original_dir
+      else
+        Dir.pwd
+      end
+      @gem_name = gem_name || find_gem_name
+      @gemspec = Bundler.load_gemspec(@gem_name+'.gemspec')
+      @no_gem = no_gem
+      @no_foodcritic = no_foodcritic
+      @no_kitchen = no_kitchen
+    end
+
+    def find_gem_name
+      specs = Dir[File.join(base, '*.gemspec')]
+      raise Error.new("Unable to automatically determine gem name from specs in #{base}. Please set the gem name via Halite::RakeHelper.install_tasks(gem_name: 'name').") if specs.length != 1
+      File.basename(specs.first, '.gemspec')
+    end
+
+    def pkg_path
+      @pkg_path ||= File.join(base, 'pkg', "#{@gem_name}-#{@gemspec.version}")
+    end
+
+    def shell
+      @shell ||= if @no_color || !STDOUT.tty?
+        Thor::Shell::Basic
+      else
+        Thor::Base.shell
+      end.new
+    end
+
+    def install
+      # Core Halite tasks
+      desc "Convert #{@gem_name}-#{@gemspec.version} to a cookbook in the pkg directory"
+      task 'chef:build' do
+        build_cookbook
+      end
+
+      desc "Push #{@gem_name}-#{@gemspec.version} to Supermarket"
+      task 'chef:release' => ['chef:build'] do
+        release_cookbook
+      end
+
+      # Patch the core gem tasks to run ours too
+      if !@no_gem
+        task 'build' => ['chef:build']
+        task 'release' => ['chef:release']
+      end
+
+      # Foodcritic doesn't have a config file, so just always try to add it.
+      if !@no_foodcritic
+        install_foodcritic
+      end
+
+      # If a .kitchen.yml exists, install the Test Kitchen tasks.
+      if !@no_kitchen && File.exists?(File.join(@base, '.kitchen.yml'))
+        install_kitchen
+      end
+    end
+
+    def install_foodcritic
+      require 'foodcritic'
+
+      desc 'Run Foodcritic linter'
+      task 'chef:foodcritic' do
+        Dir.mktmpdir('halite_test') do |path|
+          Halite.convert(gem_name, path)
+          sh("foodcritic -f any '#{path}'")
+        end
+      end
+
+      add_test_task('chef:foodcritic')
+    rescue LoadError
+      task 'chef:foodcritic' do
+        raise "Foodcritic is not available. You can use Halite::RakeHelper.install_tasks(no_foodcritic: true) to disable it."
+      end
+    end
+
+    def install_kitchen
+      desc 'Run all Test Kitchen tests'
+      task 'chef:kitchen' do
+        sh 'kitchen test -d always'
+      end
+
+      add_test_task('chef:kitchen')
+    end
+
+    def add_test_task(name)
+      # Only set a description if the task doesn't already exist
+      desc 'Run all tests' unless Rake.application.lookup('test')
+      task :test => [name]
+    end
+
+    def build_cookbook
+      # Make sure pkg/name-version exists and is empty
+      FileUtils.mkdir_p(pkg_path)
+      remove_files_in_folder(pkg_path)
+      Halite.convert(gem_name, pkg_path)
+      shell.say("#{@gem_name} #{@gemspec.version} converted to pkg/#{@gem_name}-#{@gemspec.version}/.", :green)
+    end
+
+    def release_cookbook
+      Dir.chdir(pkg_path) do
+        #sh('stove --sign')
+      end
+    end
+
+    # Remove everything in a path, but not the directory itself
+    def remove_files_in_folder(base_path)
+      existing_files = Dir.glob(File.join(base_path, '**', '*'), File::FNM_DOTMATCH).map {|path| File.expand_path(path)}.uniq.reverse # expand_path just to normalize foo/. -> foo
+      existing_files.delete(base_path) # Don't remove the base
+      # Fuck FileUtils, it is a confusing pile of fail for remove*/rm*
+      existing_files.each do |path|
+        if File.file?(path)
+          File.unlink(path)
+        elsif File.directory?(path)
+          Dir.unlink(path)
+        else
+          # Because paranoia
+          raise Error.new("Unknown type of file at '#{path}', possible symlink deletion attack")
+        end
+      end
+    end
+  end
+end