dpkg-tools 0.3.3

data/lib/dpkg-tools/package/fs_methods.rb

@@ -0,0 +1,10 @@
+module DpkgTools
+  module Package
+    module FSMethods
+      def create_dir_if_needed(target_path)
+        FileUtils.mkdir_p(target_path) unless File.exists?(target_path)
+        raise IOError, "the path '#{target_path}' points to a file, so we can't make a directory there." if File.file?(target_path)
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/gem.rb

@@ -0,0 +1,43 @@
+require 'dpkg-tools/package/gem/data'
+require 'dpkg-tools/package/gem/setup'
+require 'dpkg-tools/package/gem/control_files'
+require 'dpkg-tools/package/gem/builder'
+require 'dpkg-tools/package/gem/rake'
+
+module DpkgTools
+  module Package
+    module Gem
+      class << self
+        def setup_from_path(gem_path, options = {})
+          Setup.from_path(gem_path).create_structure
+        end
+        
+        def setup_from_name(gem_name, options = {})
+          setup = Setup.from_name(gem_name)
+          unless options[:ignore_dependencies]
+            setup.fetch_dependencies.each do |dependency|
+              dependency.create_structure
+            end
+          end
+          setup.create_structure
+        end
+        
+        def create_builder(path_to_gem_file)
+          Builder.from_file_path(path_to_gem_file)
+        end
+        
+        def config_cache(name_version_pair)
+          name, version = name_version_pair
+          @config_cache ||= {}
+          @config_cache[name_version_pair] ||= DpkgTools::Package::Config.new(name, version, :suffix => 'rubygem')
+          yield(@config_cache[name_version_pair]) if block_given?
+          @config_cache[name_version_pair]
+        end
+        
+        def rubygems_version
+          "0.9.4"
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/gem/builder.rb

@@ -0,0 +1,77 @@
+require 'rake'
+require 'rubygems'
+require 'rubygems/installer'
+require 'rubygems/doc_manager'
+
+require 'fileutils'
+
+# module GemBindir
+#   class << self
+#   def bindir(install_dir = nil)
+#     
+#   end
+# end
+
+module DpkgTools
+  module Package
+    module Gem
+      class Builder < DpkgTools::Package::Builder
+        class << self
+          include DpkgTools::Package::Gem::GemFormat
+          
+          def from_file_path(gem_file_path)
+            format, gem_byte_string = format_and_file_from_file_path(gem_file_path)
+            data = Data.new(format, gem_byte_string)
+            self.new(data)
+          end
+          
+          def format_and_file_from_file_path(gem_file_path)
+            gem_file = File.open(gem_file_path, 'rb')
+            gem_byte_string = gem_file.read
+            format = format_from_string(gem_byte_string)
+            [format, gem_byte_string]
+          end
+        end
+        
+        def config_options
+          {:suffix => 'rubygem'}
+        end
+        
+        def gem_byte_string
+          data.gem_byte_string
+        end
+        
+        def create_install_dirs
+          create_dir_if_needed(config.gem_install_path)
+          create_dir_if_needed(config.bin_install_path)
+        end
+        
+        def override_gem_bindir
+          ::Gem.module_eval %q{def self.bindir(install_dir = nil) "} + config.bin_install_path + %q{" end}
+        end
+        
+        def install_gem
+          override_gem_bindir
+          installer = ::Gem::Installer.new(config.gem_path, {:wrappers => true, :env_shebang => true})
+          installer.install(false, config.gem_install_path)
+        end
+        
+        # installs RDoc / RI docs
+        def install_docs(installed_gem_spec)
+          doc_manager = ::Gem::DocManager.new(installed_gem_spec)
+          doc_manager.generate_ri
+          doc_manager.generate_rdoc
+        end
+        
+        def build_package_files
+          installed_gem_spec = install_gem
+          install_docs(installed_gem_spec)
+        end
+        
+        def install_package_files
+          sh "chown -R root:root \"#{config.buildroot}\""
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/gem/control_files.rb

@@ -0,0 +1,23 @@
+require 'dpkg-tools/package/gem/control_files/copyright'
+require 'dpkg-tools/package/gem/control_files/changelog'
+require 'dpkg-tools/package/gem/control_files/rakefile'
+
+module DpkgTools
+  module Package
+    module Gem
+      module ControlFiles
+        class << self
+          def classes
+            [
+              DpkgTools::Package::Gem::ControlFiles::Changelog,
+              DpkgTools::Package::ControlFiles::Control,
+              DpkgTools::Package::Gem::ControlFiles::Copyright,
+              DpkgTools::Package::Gem::ControlFiles::Rakefile,
+              DpkgTools::Package::ControlFiles::Rules
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/gem/control_files/changelog.rb

@@ -0,0 +1,19 @@
+module DpkgTools
+  module Package
+    module Gem
+      module ControlFiles
+        class Changelog < DpkgTools::Package::ControlFiles::Changelog
+          def change_time
+            Time.now.rfc822
+          end
+          
+          def changelog
+            "#{config.package_name} (#{config.deb_version(data.debian_revision)}) cp-gutsy; urgency=low\n"\
+            "  * Packaged up #{data.full_name}\n"\
+            " -- Matt Patterson <matt@reprocessed.org>  #{self.change_time}\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/gem/control_files/copyright.rb

@@ -0,0 +1,24 @@
+module DpkgTools
+  module Package
+    module Gem
+      module ControlFiles
+        class Copyright < DpkgTools::Package::ControlFiles::Copyright
+          def license_file
+            # first, look for LICENSE or MIT-LICENSE in the gem
+            licenses = data.files.select do |file_path|
+              (file_path.match(/license/i) || file_path.match(/copying/i)) unless file_path.nil?
+            end
+            
+            if licenses.size == 1
+              license_path = licenses.first
+              license_files = data.file_entries.select do |meta, data|
+                meta["path"] == license_path
+              end
+              license_files.first[1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/gem/control_files/rakefile.rb

@@ -0,0 +1,19 @@
+module DpkgTools
+  module Package
+    module Gem
+      module ControlFiles
+        class Rakefile < DpkgTools::Package::ControlFiles::Rakefile
+          def rakefile
+            "require 'rubygems'\n" \
+            "require 'dpkg-tools'\n" \
+            "\n" \
+            "DpkgTools::Package::Gem::BuildTasks.new do |t|\n" \
+            "  t.root_path = File.dirname(Rake.original_dir)\n" \
+            "  t.gem_path = File.join(Rake.original_dir, '#{config.gem_filename}')\n" \
+            "end\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/gem/data.rb

@@ -0,0 +1,115 @@
+module DpkgTools
+  module Package
+    module Gem
+      class Data < DpkgTools::Package::Data
+        class << self
+          def resources_dirname
+            'gem'
+          end
+          
+          def process_extensions_map(input_hash)
+            output_hash = {}
+            input_hash.each do |gem_name, value|
+              case value
+              when Hash
+                output_hash[gem_name] = {}
+                value.each do |version_key, deps|
+                  version_key = version_key.to_s
+                  case deps
+                  when Array
+                    output_hash[gem_name][version_key] = deps.collect { |dep| {:name => dep} }
+                  when String
+                    output_hash[gem_name][version_key] = [{:name => deps}]
+                  end
+                end
+              when Array
+                output_hash[gem_name] = {'all' => value.collect { |dep| {:name => dep} }}
+              when String
+                output_hash[gem_name] = {'all' => [{:name => value}]}
+              end
+            end
+            output_hash
+          end
+          
+          def native_extensions_deps_map
+            @native_extensions_deps_map ||= process_extensions_map(YAML.load_file(File.join(resources_path, 'gems_to_deps.yml')))
+          end
+          
+          def native_extension_deps(name, version)
+            deps_map = native_extensions_deps_map[name]
+            return [] if deps_map.nil?
+            deps = deps_map[version] 
+            deps = deps_map['all'] if deps.nil?
+            return [] if deps.nil?
+            deps
+          end
+        end
+        
+        attr_reader :spec, :config, :gem_byte_string
+        
+        def initialize(format, gem_byte_string)
+          @format = format
+          @gem_byte_string = gem_byte_string
+          @spec = format.spec
+        end
+        
+        def name
+          @spec.name
+        end
+        
+        def version
+          @version ||= @spec.version.to_s
+        end
+        
+        def full_name
+          @spec.full_name
+        end
+        
+        def debian_arch
+          return 'all' if @spec.extensions.empty?
+          'i386'
+        end
+        
+        def build_dependencies
+          [{:name => "rubygems", :requirements => [">= #{Gem.rubygems_version}-1"]}, 
+           {:name => "rake-rubygem", :requirements => [">= 0.7.0-1"]},
+           {:name => "dpkg-tools-rubygem", :requirements => [">= #{DpkgTools::VERSION::STRING}-1"]}] \
+            + base_deps \
+            + self.class.native_extension_deps(name, version)
+        end
+        
+        def dependencies
+          [{:name => "rubygems", :requirements => [">= #{Gem.rubygems_version}-1"]}] + base_deps
+        end
+        
+        def summary
+          @spec.summary
+        end
+        
+        def files
+          @spec.files
+        end
+        
+        def file_entries
+          @format.file_entries
+        end
+        
+        private
+        
+        def base_deps
+          return @base_deps unless @base_deps.nil?
+          @base_deps = []
+          @spec.dependencies.each do |dependency|
+            dep_conf = DpkgTools::Package::Config.new(dependency.name, nil, :suffix => 'rubygem')
+            entry = {:name => dep_conf.package_name, :requirements => []}
+            dependency.version_requirements.as_list.each do |version|
+              entry[:requirements] << "#{version}-1"
+            end
+            @base_deps << entry
+          end
+          @base_deps
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/gem/gem_format.rb

@@ -0,0 +1,10 @@
+require 'rubygems/old_format'
+require 'rubygems/format'
+
+module DpkgTools::Package::Gem::GemFormat
+  def format_from_string(gem_byte_string)
+    gem_io = StringIO.new(gem_byte_string)
+    return ::Gem::OldFormat.from_io(gem_io) if gem_byte_string[0,20].include?("MD5SUM =")
+    ::Gem::Format.from_io(gem_io)
+  end
+end

data/lib/dpkg-tools/package/gem/rake.rb

@@ -0,0 +1,37 @@
+module DpkgTools
+  module Package
+    module Gem
+      class BuildTasks < DpkgTools::Package::BuildTasks
+        attr_accessor :gem_path, :root_path
+        
+        def check_setup
+          raise ArgumentError, "Needs to have gem_path and root_path set" unless @gem_path && @root_path
+          DpkgTools::Package::Config.root_path = self.root_path
+        end
+        
+        def create_builder
+          DpkgTools::Package::Gem.create_builder(@gem_path)
+        end
+        
+        def define_tasks
+          # build
+          task "build-arch" do
+            create_builder.build_package
+          end
+          
+          task "build-indep" do
+            create_builder.build_package
+          end
+          
+          task "binary-arch" do
+            create_builder.binary_package
+          end
+          
+          task "binary-indep" do
+            create_builder.binary_package
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/gem/setup.rb

@@ -0,0 +1,159 @@
+require 'stringio'
+require 'zlib'
+require 'rubygems/package'
+require 'rubygems/specification'
+require 'rubygems/remote_fetcher'
+
+require File.join(File.dirname(__FILE__), 'gem_format')
+
+module DpkgTools
+  module Package
+    module Gem
+      class Setup < DpkgTools::Package::Setup
+        class << self
+          include DpkgTools::Package::Gem::GemFormat
+          
+          def write_gem_file(config, gem_byte_string)
+            File.open(config.gem_path, 'wb') {|f| f.write(gem_byte_string)}
+          end
+          
+          def most_recent_spec_n_source(specs_n_sources)
+            specs_n_sources.select {|spec, source| spec.platform == ::Gem::Platform::RUBY || spec.platform.nil?}.first
+          end
+          
+          def specs_n_sources_for_name(gem_name)
+            ::Gem::RemoteInstaller.new.specs_n_sources_matching(gem_name, nil)
+          end
+        
+          def spec_n_source_for_name(gem_name)
+            most_recent_spec_n_source(specs_n_sources_for_name(gem_name))
+          end
+          
+          def most_recent_spec_n_source_satisfying_requirement(requirement, specs_n_sources)
+            okay_specs = specs_n_sources.select do |spec, source| 
+              (spec.platform == ::Gem::Platform::RUBY || spec.platform.nil?) && requirement.satisfied_by?(spec.version)
+            end
+            okay_specs.first
+          end
+          
+          def spec_n_source_for_name_and_requirement(gem_name, requirement)
+            most_recent_spec_n_source_satisfying_requirement(requirement, specs_n_sources_for_name(gem_name))
+          end
+          
+          def gem_file_from_uri(uri)
+            ::Gem::RemoteFetcher.fetcher.fetch_path(uri)
+          end
+          
+          def gem_uri_from_spec_n_source(spec, source_uri)
+            source_uri + "/gems/#{spec.full_name}.gem"
+          end
+          
+          def format_and_file_from_path(gem_path)
+            gem_byte_string = File.read(gem_path)
+            format = format_from_string(gem_byte_string)
+            [format, gem_byte_string]
+          end
+          
+          def cache_key_from_spec(spec)
+            "#{spec.name}-#{spec.version}"
+          end
+          
+          def from_spec_and_source(spec, source)
+            gem_byte_string = gem_file_from_uri(gem_uri_from_spec_n_source(spec, source))
+            self.new(DpkgTools::Package::Gem::Data.new(format_from_string(gem_byte_string), gem_byte_string))
+          end
+          
+          def from_spec_and_source_via_cache(spec, source)
+            cache_key = cache_key_from_spec(spec)
+            return dependency_cache[cache_key] if dependency_cache.has_key?(cache_key)
+            dependency_cache[cache_key] = from_spec_and_source(spec, source)
+          end
+          
+          def from_name(gem_name)
+            from_spec_and_source_via_cache(*spec_n_source_for_name(gem_name))
+          end
+          
+          def from_name_and_requirement(gem_name, requirement)
+            from_spec_and_source_via_cache(*spec_n_source_for_name_and_requirement(gem_name, requirement))
+          end
+          
+          def from_path(gem_path)
+            format, gem_byte_string = format_and_file_from_path(gem_path)
+            self.new(DpkgTools::Package::Gem::Data.new(format, gem_byte_string))
+          end
+          
+          def write_orig_tarball(config, gem_byte_string)
+            output_io = StringIO.new
+            gz_io = Zlib::GzipWriter.new(output_io)
+            tar_io = StringIO.new
+            ::Gem::Package::TarWriter.new(tar_io) do |tar_stream|
+              tar_stream.mkdir(config.package_dir_name, 0755)
+              tar_stream.add_file("#{config.package_dir_name}/#{config.gem_filename}", 0644) {|f| f.write(gem_byte_string) }
+            end
+            tar_io.flush
+            tar_io.rewind
+            gz_io.write(tar_io.read)
+            gz_io.finish
+            output_io.rewind
+            File.open(File.join(config.orig_tarball_path), 'w') do |f| 
+              f.write(output_io.read)
+            end
+          end
+          
+          def dependency_cache
+            @dependency_cache ||= {}
+          end
+        end
+        
+        attr_reader :data, :config
+        
+        def control_file_classes
+          DpkgTools::Package::Gem::ControlFiles.classes
+        end
+        
+        def config_options
+          {:suffix => 'rubygem'}
+        end
+        
+        def fetch_gem_file
+          self.class.fetch_gem_file(@source_uri + "/gems/#{@spec.full_name}.gem")
+        end
+        
+        def write_orig_tarball
+          self.class.write_orig_tarball(config, data.gem_byte_string)
+        end
+        
+        def write_gem_file
+          self.class.write_gem_file(config, data.gem_byte_string)
+        end
+        
+        def prepare_package
+          write_orig_tarball
+          write_gem_file
+        end
+        
+        def fetch_dependency(dependency)
+          dep_setup = self.class.from_name_and_requirement(dependency.name, dependency.version_requirements)
+          return dep_setup if dep_setup.fetched_dependencies?
+          [dep_setup] + dep_setup.fetch_dependencies
+        end
+        
+        def fetch_dependencies
+          deps = data.spec.dependencies.collect do |dependency|
+            fetch_dependency(dependency)
+          end
+          @fetched_dependencies = true
+          deps.flatten
+        end
+        
+        def fetched_dependencies?
+          @fetched_dependencies ||= false
+        end
+        
+        def dependency_cache
+          self.class.dependency_cache
+        end
+      end
+    end
+  end
+end