fpm-fry 0.2.2 → 0.3.0

data/lib/fpm/fry/recipe.rb

@@ -1,26 +1,28 @@
 require 'fpm/fry/source'
-require 'fpm/fry/source/package'
+require 'fpm/fry/source/archive'
 require 'fpm/fry/source/dir'
 require 'fpm/fry/source/patched'
 require 'fpm/fry/source/git'
 require 'fpm/fry/plugin'
-require 'fpm/fry/os_db'
+require 'fpm/fry/exec'
 require 'shellwords'
 require 'cabin'
-require 'open3'
 module FPM; module Fry
 
+  # A FPM::Fry::Recipe contains all information needed to build a package.
+  #
+  # It is usually created by {FPM::Fry::Recipe::Builder}.
   class Recipe
 
+    # A FPM::Fry::Recipe::Step is a named build step.
+    #
+    # @see FPM::Fry::Recipe#steps
     class Step < Struct.new(:name, :value)
       def to_s
         value.to_s
       end
     end
 
-    class DuplicateDependency < ArgumentError
-    end
-
     class PackageRecipe
       attr_accessor :name,
         :iteration,
@@ -60,6 +62,10 @@ module FPM; module Fry
 
       alias dependencies depends
 
+      # Applies settings to output package
+      # @param [FPM::Package] package
+      # @return [FPM::Package] package
+      # @api private
       def apply_output( package )
         package.name = name
         package.version = version
@@ -87,8 +93,11 @@ module FPM; module Fry
 
       alias apply apply_output
 
+      # @api private
       SYNTAX_CHECK_SHELLS = ['/bin/sh','/bin/bash', '/bin/dash']
 
+      # Lints the settings for some common problems
+      # @return [Array<String>] problems
       def lint
         problems = []
         problems << "Name is empty." if name.to_s == ''
@@ -110,28 +119,37 @@ module FPM; module Fry
             problems << "#{type} script doesn't have a valid command in shebang"
           end
           if SYNTAX_CHECK_SHELLS.include? args[0]
-            sin, sout, serr, th = Open3.popen3(args[0],'-n')
-            sin.write(s)
-            sin.close
-            if th.value.exitstatus != 0
-              problems << "#{type} script is not valid #{args[0]} code: #{serr.read.chomp}"
+            begin
+              Exec::exec(args[0],'-n', stdin_data: s)
+            rescue Exec::Failed => e
+              problems << "#{type} script is not valid #{args[0]} code: #{e.stderr.chomp}"
             end
-            serr.close
-            sout.close
           end
         end
         return problems
       end
     end
 
-    attr_accessor :source,
-      :build_mounts,
-      :apt_setup,
-      :before_build_steps,
-      :steps,
-      :packages,
-      :build_depends,
-      :input_hooks
+    # @return [FPM::Fry::Source] the source used for building
+    attr_accessor :source
+
+    attr_accessor :build_mounts
+    attr_accessor :apt_setup
+
+    # @return [Array<#to_s>] steps that will be carried out before build
+    attr_accessor :before_build_steps
+
+    # @return [Array<#to_s>] steps that will be carried out during build
+    attr_accessor :steps
+
+    # @return [Array<FPM::Fry::PackageRecipe>] a list of packages that will be created
+    attr_accessor :packages
+
+    # @return [Hash<String,Hash>] build dependencies
+    attr_accessor :build_depends
+
+    # @return [Array<#call>] hooks that will be called on the input package
+    attr_accessor :input_hooks
 
     def initialize
       @source = Source::Null
@@ -145,6 +163,8 @@ module FPM; module Fry
       @apt_setup = []
     end
 
+    # Calculates all dependencies of this recipe
+    # @return [Hash<String,Hash>] the dependencies
     def depends
       depends = @packages.map(&:depends).inject(:merge)
       @packages.map(&:name).each do | n |
@@ -153,10 +173,15 @@ module FPM; module Fry
       return depends
     end
 
+    # Checks all packages for common errors
+    # @return [Array<String>] problems
     def lint
       packages.flat_map(&:lint)
     end
 
+    # Applies input settings to package
+    # @param [FPM::Package] package
+    # @return [FPM::Package]
     def apply_input( package )
       input_hooks.each{|h| h.call(self, package) }
       return package

data/lib/fpm/fry/recipe/builder.rb

@@ -7,13 +7,26 @@ module FPM::Fry
     class NotFound < StandardError
     end
 
-    class PackageBuilder < Struct.new(:variables, :package_recipe)
+    class PackageBuilder
 
+      # @return [Hash<Symbol,Object>]
+      attr :variables
+
+      # @return [FPM::Fry::PackageRecipe]
+      attr :package_recipe
+
+      # @return [Cabin::Channel]
       attr :logger
 
-      def initialize( variables, recipe = PackageRecipe.new, options = {})
-        super(variables, recipe)
+      # @return [FPM::Fry::Inspector,nil]
+      attr :inspector
+
+      # @api private
+      def initialize( variables, package_recipe, options = {})
+        @variables = variables
+        @package_recipe = package_recipe
         @logger = options.fetch(:logger){ Cabin::Channel.get }
+        @inspector = options[:inspector]
       end
 
       def flavour
@@ -174,17 +187,17 @@ module FPM::Fry
 
     class Builder < PackageBuilder
 
+      # @return [FPM::Fry::Recipe]
       attr :recipe
 
-      def initialize( variables, recipe = Recipe.new, options = {})
+      # @param [Hash<Symbol,Object>] variables
+      # @param [Hash] options
+      # @option options [FPM::Fry::Recipe] :recipe (Recipe.new)
+      # @option options [Cabin::Channel] :logger (default cabin channel)
+      # @option options [FPM::Fry::Inspector] :inspector
+      def initialize( variables, options = {} )
+        recipe = options.fetch(:recipe){ Recipe.new }
         variables = variables.dup
-        if variables[:distribution] && !variables[:flavour] && OsDb[variables[:distribution]]
-          variables[:flavour] = OsDb[variables[:distribution]][:flavour]
-        end
-        if !variables[:codename] && OsDb[variables[:distribution]] && variables[:distribution_version]
-          codename = OsDb[variables[:distribution]][:codenames].find{|name,version| variables[:distribution_version].start_with? version }
-          variables[:codename] = codename[0] if codename
-        end
         variables.freeze
         @recipe = recipe
         @before_build = false
@@ -266,7 +279,7 @@ module FPM::Fry
         pr.version = package_recipe.version
         pr.iteration = package_recipe.iteration
         recipe.packages << pr
-        PackageBuilder.new(variables, pr).instance_eval(&block)
+        PackageBuilder.new(variables, pr, logger: logger, inspector: inspector).instance_eval(&block)
       end
 
     protected
@@ -289,7 +302,7 @@ module FPM::Fry
 
       def register_default_source_types!
         register_source_type Source::Git
-        register_source_type Source::Package
+        register_source_type Source::Archive
         register_source_type Source::Dir
       end
 

data/lib/fpm/fry/source.rb

@@ -1,34 +1,35 @@
+require 'fpm/fry/with_data'
 module FPM; module Fry ; module Source
 
+  # Raised when building a cache failed.
   class CacheFailed < StandardError
-
-    attr :data
-
-    def initialize(e, data = {})
-      if e.kind_of? Exception
-        @data = {reason: e}.merge data
-        super(e.message)
-      else
-        @data = data.dup
-        super(e.to_s)
-      end
-    end
+    include WithData
   end
 
+  # A special source that is empty.
   module Null
 
+    # A special cache that is empty.
     module Cache
+
+      # @return [IO] an empty tar
       def self.tar_io
         StringIO.new("\x00"*1024)
       end
+
+      # @return [Hash] an empty hash
       def self.file_map
         return {}
       end
+
+      # @return [String] 32 times zero
       def self.cachekey
         return '0' * 32
       end
     end
 
+    # @see FPM::Fry::Source::Null::Cache
+    # @return {FPM::Fry::Source::Null::Cache}
     def self.build_cache(*_)
       return Cache
     end
@@ -37,6 +38,7 @@ module FPM; module Fry ; module Source
 
   class << self
 
+    # @api private
     def guess_regex(rx, url)
       if m = rx.match(url.to_s)
         return m[0].size

data/lib/fpm/fry/source/{package.rb → archive.rb}

@@ -4,32 +4,65 @@ require 'net/http'
 require 'forwardable'
 require 'zlib'
 require 'fpm/fry/source'
+require 'fpm/fry/exec'
 require 'cabin'
 module FPM; module Fry ; module Source
-  class Package
+  # Used to build from an archive.
+  #
+  # @example in a recipe
+  #   source 'http://curl.haxx.se/download/curl-7.36.0.tar.gz',
+  #     checksum: '33015795d5650a2bfdd9a4a28ce4317cef944722a5cfca0d1563db8479840e90'
+  #
+  # It is highly advised to supply a checksum ( althought it's not mandatory ). 
+  # This checksum will be used to test for cache validity and data integrity. The 
+  # checksum algorithm is automatically guessed based on the length of the checksum.
+  #
+  #   - 40 characters = sha1
+  #   - 64 characters = sha256
+  # 
+  # Let's be honest: all other checksum algorithms aren't or shouldn't be in use anyway.
+  class Archive
 
     REGEX = %r!\Ahttps?:!
 
+    # @return [:archive]
     def self.name
       :package
     end
 
     def self.aliases
-      [:http]
+      [:package,:http]
     end
 
+    # Guesses if the given url is an archive.
+    # 
+    # @example not an archive
+    #   FPM::Fry::Source::Archive.guess("bzr://something") # => nil
+    #
+    # @example an archive
+    #   FPM::Fry::Source::Archive.guess("https://some/thing.tar.gz") #=> 6
+    #
+    # @return [nil] when it's not an archive
+    # @return [Numeric] number of characters used
     def self.guess( url )
       Source::guess_regex(REGEX, url)
     end
 
+    # Raised when too many redirects happened.
     class RedirectError < CacheFailed
     end
 
+    # Raised when the archive type is not known.
+    class UnknownArchiveType < StandardError
+      include WithData
+    end
+
     class Cache < Struct.new(:package,:tempdir)
       extend Forwardable
 
-      def_delegators :package, :url, :checksum, :checksum_algorithm, :agent, :logger, :file_map
+      def_delegators :package, :url, :checksum, :checksum_algorithm, :logger, :file_map
 
+      # @return [String] cachekey which is equal to the checksum
       def cachekey
         @observed_checksum || checksum
       end
@@ -92,7 +125,7 @@ module FPM; module Fry ; module Source
           case(resp)
           when Net::HTTPRedirection
             if redirs == 0
-              raise RedirectError, "Too many redirects"
+              raise RedirectError.new("Too many redirects", url: url.to_s, location: resp['location'])
             end
             logger.debug("Following redirect", url: url.to_s , location: resp['location'])
             return fetch_url( resp['location'], redirs - 1, &block)
@@ -119,9 +152,7 @@ module FPM; module Fry ; module Source
 
       def copy_to(dst)
         update!
-        cmd = ['tar','-xf',tempfile,'-C',dst]
-        logger.debug("Running tar",cmd: cmd)
-        system(*cmd)
+        Exec['tar','-xf',tempfile,'-C',dst, logger: logger]
       end
 
     protected
@@ -142,9 +173,7 @@ module FPM; module Fry ; module Source
 
       def tar_io
         update!
-        cmd = ['bzcat',tempfile]
-        logger.debug("Running bzcat",cmd: cmd)
-        return IO.popen(cmd)
+        return Exec::popen('bzcat', tempfile, logger: logger)
       end
 
     end
@@ -163,20 +192,14 @@ module FPM; module Fry ; module Source
           copy_to( workdir )
           File.rename(workdir, unpacked_tmpdir)
         end
-        cmd = ['tar','-c','.']
-        logger.debug("Running tar",cmd: cmd, dir: unpacked_tmpdir)
-        ::Dir.chdir(unpacked_tmpdir) do
-          return IO.popen(cmd)
-        end
+        return Exec::popen('tar','-c','.', chdir: unpacked_tmpdir)
       end
 
       def copy_to(dst)
         update!
-        cmd = ['unzip', tempfile, '-d', dst ]
-        logger.debug("Running unzip",cmd: cmd)
-        system(*cmd, out: '/dev/null')
+        Exec['unzip', tempfile, '-d', dst ]
       end
-
+    private
       def unpacked_tmpdir
         File.join(tempdir, cachekey)
       end
@@ -186,12 +209,8 @@ module FPM; module Fry ; module Source
 
       def tar_io
         update!
-        cmd = ['tar','-c',::File.basename(tempfile)]
         dir = File.dirname(tempfile)
-        logger.debug("Running tar",cmd: cmd, dir: dir)
-        ::Dir.chdir(dir) do
-          return IO.popen(cmd)
-        end
+        Exec::popen('tar','-c',::File.basename(tempfile), logger: logger, chdir: dir)
       end
 
       def copy_to(dst)
@@ -211,26 +230,44 @@ module FPM; module Fry ; module Source
       '.bundle' => PlainCache
     }
 
-    attr :file_map, :data, :url, :extension, :checksum, :checksum_algorithm, :agent, :logger
+    attr :file_map, :data, :url, :checksum, :checksum_algorithm, :logger
 
+    # @param [URI] url
+    # @param [Hash] options
+    # @option options [Cabin::Channel] :logger (default cabin channel)
+    # @option options [String] :checksum a checksum of the archive
+    # @raise [UnknownArchiveType] when the archive type is unknown
     def initialize( url, options = {} )
       @url = URI(url)
-      @extension = options.fetch(:extension){
-        CACHE_CLASSES.keys.find{|ext|
-          @url.path.end_with?(ext)
-        }
-      }
+      @cache_class = guess_cache_class(@url)
       @logger = options.fetch(:logger){ Cabin::Channel.get }
       @checksum = options[:checksum]
       @checksum_algorithm = guess_checksum_algorithm(options[:checksum])
       @file_map = options.fetch(:file_map){ {'' => ''} }
     end
 
+    # Creates a cache.
+    #
+    # @param [String] tempdir
+    # @return [TarCache] for plain .tar files
+    # @return [TarGzCache] for .tar.gz files
+    # @return [TarBz2Cache] for .tar.bz2 files
+    # @return [ZipCache] for .zip files
+    # @return [PlainCache] for .bin files
     def build_cache(tempdir)
-      CACHE_CLASSES.fetch(extension).new(self, tempdir)
+      @cache_class.new(self, tempdir)
     end
   private
 
+    def guess_cache_class( url )
+      CACHE_CLASSES.each do |ext,klass|
+        if url.path.end_with?(ext)
+          return klass
+        end
+      end
+      raise UnknownArchiveType.new("Unknown archive type", url: url.to_s, known_extensions: CACHE_CLASSES.keys)
+    end
+
     def guess_checksum_algorithm( checksum )
       case(checksum)
       when nil