bundix 2.3.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 623983fdd769dae25b35ce73300b7c15e2e05406
-  data.tar.gz: 467820098d81bee233d3292e0a26cca9924e5c62
+SHA256:
+  metadata.gz: 3fbcd152e7e9e610f2357bd6ee0658d84fa9bbcd497c3ced755d7efafb9547a9
+  data.tar.gz: 9f8eb407611278f324960b8393e7452d4b9385434cfbc028db61dbddc7335f3d
 SHA512:
-  metadata.gz: 730d8af2547d66f2fb33e1e5dd5c1afafec4f30dbc896de6f942552f485ae187e001f65ea786486553110f813e798e7cb8010f9c4012f9a82b686cc9b77bf359
-  data.tar.gz: e8e3ffa6148a782fe38c44128e11c86e836681eec0e03fddcccd2800b96a430f8f48f5e0c0923ef4b87787c6ccb14e3e5de18287a1acfe5a36c35f9bf9fa0e62
+  metadata.gz: 564b4bf345a72c9556d3a776c7d39f62f1ee060b71c5a9c99d7b29ad43096d1d321a6e860da52124b43a4f9675dfc0f3bdbd1a5fe2dadb0d6561967b3e17f4b3
+  data.tar.gz: 0565a326c0babef8e995afb905895c6c591c27926d5b7fb011a59478c89f128eabd3aa18c10dfa1f9f040663f7e48c7c86697a55973ad37a77fb07ed8b693d57

data/bin/bundix

@@ -1,117 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'optparse'
-require 'tmpdir'
-require 'tempfile'
-require 'pathname'
+require_relative '../lib/bundix/commandline'
 
-require_relative '../lib/bundix'
-
-options = {
-  ruby: 'ruby',
-  bundle_pack_path: 'vendor/bundle',
-  gemfile: 'Gemfile',
-  lockfile: 'Gemfile.lock',
-  gemset: 'gemset.nix',
-}
-
-op = OptionParser.new do |o|
-  o.on '-m', '--magic', 'lock, pack, and write dependencies' do
-    options[:magic] = true
-  end
-
-  o.on '--ruby=ruby', 'ruby version to use for magic and init, defaults to latest' do |value|
-    options[:ruby] = value
-  end
-
-  o.on '--bundle-pack-path=vendor/bundle', "path to pack the magic" do |value|
-    options[:bundle_pack_path] = value
-  end
-
-  o.on '-i', '--init', "initialize a new shell.nix for nix-shell (won't overwrite old ones)" do
-    options[:init] = true
-  end
-
-  o.on '--gemset=gemset.nix', 'path to the gemset.nix' do |value|
-    options[:gemset] = File.expand_path(value)
-  end
-
-  o.on '--lockfile=Gemfile.lock', 'path to the Gemfile.lock' do |value|
-    options[:lockfile] = File.expand_path(value)
-  end
-
-  o.on '--gemfile=Gemfile', 'path to the Gemfile' do |value|
-    options[:gemfile] = File.expand_path(value)
-  end
-
-  o.on '-d', '--dependencies', 'include gem dependencies (deprecated)' do
-    warn '--dependencies/-d is deprecated because'
-    warn 'dependencies will always be fetched'
-  end
-
-  o.on '-q', '--quiet', 'only output errors' do
-    options[:quiet] = true
-  end
-
-  o.on '-l', '--lock', 'generate Gemfile.lock first' do
-    options[:lock] = true
-  end
-
-  o.on '-v', '--version', 'show the version of bundix' do
-    puts Bundix::VERSION
-    exit
-  end
-
-  o.on '--env', 'show the environment in bundix' do
-    system('env')
-    exit
-  end
-end
-
-op.parse!
-$VERBOSE = !options[:quiet]
-
-if options[:magic]
-  fail unless system(
-    Bundix::NIX_SHELL, '-p', options[:ruby],
-    "bundler.override { ruby = #{options[:ruby]}; }",
-    "--command", "bundle lock --lockfile=#{options[:lockfile]}")
-  fail unless system(
-    Bundix::NIX_SHELL, '-p', options[:ruby],
-    "bundler.override { ruby = #{options[:ruby]}; }",
-    "--command", "bundle pack --all --path #{options[:bundle_pack_path]}")
-end
-
-if options[:init]
-  if File.file?('shell.nix')
-    warn "won't override existing shell.nix"
-  else
-    shell_nix = File.read(File.expand_path('../template/shell.nix', __dir__))
-    shell_nix.gsub!('PROJECT', File.basename(Dir.pwd))
-    shell_nix.gsub!('RUBY', options[:ruby])
-    shell_nix.gsub!('LOCKFILE', "./#{Pathname(options[:lockfile]).relative_path_from(Pathname('./'))}")
-    shell_nix.gsub!('GEMSET', "./#{Pathname(options[:gemset]).relative_path_from(Pathname('./'))}")
-    File.write('shell.nix', shell_nix)
-  end
-end
-
-if options[:lock]
-  lock = !File.file?(options[:lockfile])
-  lock ||= File.mtime(options[:gemfile]) > File.mtime(options[:lockfile])
-  if lock
-    system('bundle', 'lock')
-    fail 'bundle lock failed' unless $?.success?
-  end
-end
-
-gemset = Bundix.new(options).convert
-
-tempfile = Tempfile.new('gemset.nix', encoding: 'UTF-8')
-begin
-  Bundix.object2nix(gemset, 2, tempfile)
-  tempfile.flush
-  FileUtils.cp(tempfile.path, options[:gemset])
-ensure
-  tempfile.close!
-  tempfile.unlink
-end
+Bundix::CommandLine.run

data/lib/bundix.rb

@@ -6,44 +6,92 @@ require 'pp'
 
 require_relative 'bundix/version'
 require_relative 'bundix/source'
+require_relative 'bundix/nixer'
 
 class Bundix
   NIX_INSTANTIATE = 'nix-instantiate'
   NIX_PREFETCH_URL = 'nix-prefetch-url'
   NIX_PREFETCH_GIT = 'nix-prefetch-git'
-  NIX_BUILD = 'nix-build'
   NIX_HASH = 'nix-hash'
   NIX_SHELL = 'nix-shell'
 
-  FETCHURL_FORCE = File.expand_path('../bundix/fetchurl-force.nix', __FILE__)
-  FETCHURL_FORCE_CHECK = lambda do |_, out|
-    out =~ /success! failing outer nix build.../
-  end
-
   SHA256_32 = %r(^[a-z0-9]{52}$)
-  SHA256_16 = %r(^[a-f0-9]{64}$)
 
   attr_reader :options
 
+  attr_accessor :fetcher
+
+  class Dependency < Bundler::Dependency
+    def initialize(name, version, options={}, &blk)
+      super(name, version, options, &blk)
+      @bundix_version = version
+    end
+
+    attr_reader :version
+  end
+
   def initialize(options)
     @options = { quiet: false, tempfile: nil }.merge(options)
+    @fetcher = Fetcher.new
   end
 
   def convert
     cache = parse_gemset
     lock = parse_lockfile
+    dep_cache = build_depcache(lock)
 
     # reverse so git comes last
     lock.specs.reverse_each.with_object({}) do |spec, gems|
-      gem = find_cached_spec(spec, cache) || convert_spec(spec, cache)
+      gem = find_cached_spec(spec, cache) || convert_spec(spec, cache, dep_cache)
       gems.merge!(gem)
 
-      gems[spec.name]['dependencies'] = spec.dependencies.map(&:name) - ['bundler']
+      if spec.dependencies.any?
+        gems[spec.name]['dependencies'] = spec.dependencies.map(&:name) - ['bundler']
+      end
+    end
+  end
+
+  def groups(spec, dep_cache)
+    {groups: dep_cache.fetch(spec.name).groups}
+  end
+
+  PLATFORM_MAPPING = {}
+
+  {
+    "ruby" => [{engine: "ruby"}, {engine:"rbx"}, {engine:"maglev"}],
+    "mri" => [{engine: "ruby"}, {engine: "maglev"}],
+    "rbx" => [{engine: "rbx"}],
+    "jruby" => [{engine: "jruby"}],
+    "mswin" => [{engine: "mswin"}],
+    "mswin64" => [{engine: "mswin64"}],
+    "mingw" => [{engine: "mingw"}],
+    "truffleruby" => [{engine: "ruby"}],
+    "x64_mingw" => [{engine: "mingw"}],
+  }.each do |name, list|
+    PLATFORM_MAPPING[name] = list
+    %w(1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6).each do |version|
+      PLATFORM_MAPPING["#{name}_#{version.sub(/[.]/,'')}"] = list.map do |platform|
+        platform.merge(:version => version)
+      end
     end
   end
 
-  def convert_spec(spec, cache)
-    {spec.name => {version: spec.version.to_s, source: Source.new(spec).convert}}
+  def platforms(spec, dep_cache)
+    # c.f. Bundler::CurrentRuby
+    platforms = dep_cache.fetch(spec.name).platforms.map do |platform_name|
+      PLATFORM_MAPPING[platform_name.to_s]
+    end.flatten
+
+    {platforms: platforms}
+  end
+
+  def convert_spec(spec, cache, dep_cache)
+    {
+      spec.name => {
+        version: spec.version.to_s,
+        source: Source.new(spec, fetcher).convert
+      }.merge(platforms(spec, dep_cache)).merge(groups(spec, dep_cache))
+    }
   rescue => ex
     warn "Skipping #{spec.name}: #{ex}"
     puts ex.backtrace
@@ -70,12 +118,53 @@ class Bundix
     {name => cached} if cached
   end
 
+  def build_depcache(lock)
+    definition = Bundler::Definition.build(options[:gemfile], options[:lockfile], false)
+    dep_cache = {}
+
+    definition.dependencies.each do |dep|
+      dep_cache[dep.name] = dep
+    end
+
+    lock.specs.each do |spec|
+      dep_cache[spec.name] ||= Dependency.new(spec.name, nil, {})
+    end
+
+    begin
+      changed = false
+      lock.specs.each do |spec|
+        as_dep = dep_cache.fetch(spec.name)
+
+        spec.dependencies.each do |dep|
+          cached = dep_cache.fetch(dep.name) do |name|
+            if name != "bundler"
+              raise KeyError, "Gem dependency '#{name}' not specified in #{lockfile}"
+            end
+            dep_cache[name] = Dependency.new(name, lock.bundler_version, {})
+          end
+
+          if !((as_dep.groups - cached.groups) - [:default]).empty? or !(as_dep.platforms - cached.platforms).empty?
+            changed = true
+            dep_cache[cached.name] = (Dependency.new(cached.name, nil, {
+              "group" => as_dep.groups | cached.groups,
+              "platforms" => as_dep.platforms | cached.platforms
+            }))
+
+            cc = dep_cache[cached.name]
+          end
+        end
+      end
+    end while changed
+
+    return dep_cache
+  end
 
   def parse_gemset
     path = File.expand_path(options[:gemset])
     return {} unless File.file?(path)
-    json = Bundix.sh(
-      NIX_INSTANTIATE, '--eval', '-E', "builtins.toJSON(import #{path})")
+    json = Bundix.sh(NIX_INSTANTIATE, '--eval', '-E', %(
+      builtins.toJSON (import #{Nixer.serialize(path)}))
+    )
     JSON.parse(json.strip.gsub(/\\"/, '"')[1..-2])
   end
 
@@ -83,37 +172,8 @@ class Bundix
     Bundler::LockfileParser.new(File.read(options[:lockfile]))
   end
 
-  def self.object2nix(obj, level = 2, out = '')
-    case obj
-    when Hash
-      out << "{\n"
-      obj.sort_by{|k, v| k.to_s.downcase }.each do |(k, v)|
-        out << ' ' * level
-        if k.to_s =~ /^[a-zA-Z_-]+[a-zA-Z0-9_-]*$/
-          out << k.to_s
-        else
-          object2nix(k, level + 2, out)
-        end
-        out << ' = '
-        object2nix(v, level + 2, out)
-        out << (v.is_a?(Hash) ? "\n" : ";\n")
-      end
-      out << (' ' * (level - 2)) << (level == 2 ? '}' : '};')
-    when Array
-      out << '[' << obj.sort.map{|o| o.to_str.dump }.join(' ') << ']'
-    when String
-      out << obj.dump
-    when Symbol
-      out << obj.to_s.dump
-    when true, false
-      out << obj.to_s
-    else
-      fail obj.inspect
-    end
-  end
-
   def self.sh(*args, &block)
-    out, status = Open3.capture2e(*args)
+    out, status = Open3.capture2(*args)
     unless block_given? ? block.call(status, out) : status.success?
       puts "$ #{args.join(' ')}" if $VERBOSE
       puts out if $VERBOSE

data/lib/bundix/commandline.rb

@@ -0,0 +1,169 @@
+require 'optparse'
+require 'tmpdir'
+require 'tempfile'
+require 'pathname'
+
+require_relative '../bundix'
+require_relative 'shell_nix_context'
+
+class Bundix
+  class CommandLine
+
+    DEFAULT_OPTIONS = {
+      ruby: 'ruby',
+      bundle_pack_path: 'vendor/bundle',
+      gemfile: 'Gemfile',
+      lockfile: 'Gemfile.lock',
+      gemset: 'gemset.nix',
+      project: File.basename(Dir.pwd)
+    }
+
+    def self.run
+      self.new.run
+    end
+
+    def initialize
+      @options = DEFAULT_OPTIONS.clone
+    end
+
+    attr_accessor :options
+
+    def run
+      parse_options
+      handle_magic
+      handle_lock
+      handle_init
+      gemset = build_gemset
+      save_gemset(gemset)
+    end
+
+    def parse_options
+      op = OptionParser.new do |o|
+        o.on '-m', '--magic', 'lock, pack, and write dependencies' do
+          options[:magic] = true
+        end
+
+        o.on "--ruby=#{options[:ruby]}", 'ruby version to use for magic and init, defaults to latest' do |value|
+          options[:ruby] = value
+        end
+
+        o.on "--bundle-pack-path=#{options[:bundle_pack_path]}", "path to pack the magic" do |value|
+          options[:bundle_pack_path] = value
+        end
+
+        o.on '-i', '--init', "initialize a new shell.nix for nix-shell (won't overwrite old ones)" do
+          options[:init] = true
+        end
+
+        o.on "--gemset=#{options[:gemset]}", 'path to the gemset.nix' do |value|
+          options[:gemset] = File.expand_path(value)
+        end
+
+        o.on "--lockfile=#{options[:lockfile]}", 'path to the Gemfile.lock' do |value|
+          options[:lockfile] = File.expand_path(value)
+        end
+
+        o.on "--gemfile=#{options[:gemfile]}", 'path to the Gemfile' do |value|
+          options[:gemfile] = File.expand_path(value)
+        end
+
+        o.on '-d', '--dependencies', 'include gem dependencies (deprecated)' do
+          warn '--dependencies/-d is deprecated because'
+          warn 'dependencies will always be fetched'
+        end
+
+        o.on '-q', '--quiet', 'only output errors' do
+          options[:quiet] = true
+        end
+
+        o.on '-l', '--lock', 'generate Gemfile.lock first' do
+          options[:lock] = true
+        end
+
+        o.on '-v', '--version', 'show the version of bundix' do
+          puts Bundix::VERSION
+          exit
+        end
+
+        o.on '--env', 'show the environment in bundix' do
+          system('env')
+          exit
+        end
+      end
+
+      op.parse!
+      $VERBOSE = !options[:quiet]
+      options
+    end
+
+    def handle_magic
+      ENV['BUNDLE_GEMFILE'] = options[:gemfile]
+
+      if options[:magic]
+        fail unless system(
+          Bundix::NIX_SHELL, '-p', options[:ruby],
+          "bundler.override { ruby = #{options[:ruby]}; }",
+          "--command", "bundle lock --lockfile=#{options[:lockfile]}")
+        fail unless system(
+          Bundix::NIX_SHELL, '-p', options[:ruby],
+          "bundler.override { ruby = #{options[:ruby]}; }",
+          "--command", "bundle pack --all --path #{options[:bundle_pack_path]}")
+      end
+    end
+
+    def shell_nix_context
+      ShellNixContext.from_hash(options)
+    end
+
+    def shell_nix_string
+      tmpl = ERB.new(File.read(File.expand_path('../../template/shell-nix.erb', __dir__)))
+      tmpl.result(shell_nix_context.bind)
+    end
+
+    def handle_init
+      if options[:init]
+        if File.file?('shell.nix')
+          warn "won't override existing shell.nix but here is what it'd look like:"
+          puts shell_nix_string
+        else
+          File.write('shell.nix', shell_nix_string)
+        end
+      end
+    end
+
+    def handle_lock
+      if options[:lock]
+        lock = !File.file?(options[:lockfile])
+        lock ||= File.mtime(options[:gemfile]) > File.mtime(options[:lockfile])
+        if lock
+          ENV.delete('BUNDLE_PATH')
+          ENV.delete('BUNDLE_FROZEN')
+          ENV.delete('BUNDLE_BIN_PATH')
+          system('bundle', 'lock')
+          fail 'bundle lock failed' unless $?.success?
+        end
+      end
+    end
+
+    def build_gemset
+      Bundix.new(options).convert
+    end
+
+    def object2nix(obj)
+      Nixer.serialize(obj)
+    end
+
+    def save_gemset(gemset)
+      tempfile = Tempfile.new('gemset.nix', encoding: 'UTF-8')
+      begin
+        tempfile.write(object2nix(gemset))
+        tempfile.flush
+        FileUtils.cp(tempfile.path, options[:gemset])
+        FileUtils.chmod(0644, options[:gemset])
+      ensure
+        tempfile.close!
+        tempfile.unlink
+      end
+    end
+  end
+end

data/lib/bundix/nixer.rb

@@ -0,0 +1,104 @@
+require 'erb'
+
+class Hash
+  # regretfully, duckpunching
+  def <=>(other)
+    if other.is_a?(Hash)
+      larray = to_a.sort{|l,r| Bundix::Nixer.order(l,r)}
+      rarray = other.to_a.sort{|l,r| Bundix::Nixer.order(l,r)}
+      larray <=> rarray
+    else
+      nil
+    end
+  end
+end
+
+class Bundix
+  class Nixer
+    class << self
+      def serialize(obj)
+        new(obj).serialize
+      end
+
+      def order(left, right)
+        if right.is_a?(left.class)
+          if right.respond_to?(:<=>)
+            cmp = right <=> left
+            return -1 * (cmp) unless cmp.nil?
+          end
+        end
+
+        if left.is_a?(right.class)
+          if left.respond_to?(:<=>)
+            cmp = right <=> left
+            if cmp.nil?
+              return class_order(left, right)
+            else
+              return cmp
+            end
+          end
+        end
+
+        return class_order(left, right)
+      end
+
+      def class_order(left, right)
+        left.class.name <=> right.class.name # like Erlang
+      end
+    end
+
+    attr_reader :level, :obj
+
+    SET_T = ERB.new(File.read(File.expand_path("../../template/nixer/set.erb", __dir__)).chomp)
+    LIST_T = ERB.new(File.read(File.expand_path("../../template/nixer/list.erb", __dir__)).chomp)
+
+    def initialize(obj, level = 0)
+      @obj = obj
+      @level = level
+    end
+
+    def indent
+      ' ' * (level + 2)
+    end
+
+    def outdent
+      ' ' * level
+    end
+
+    def sub(obj, indent = 0)
+      self.class.new(obj, level + indent).serialize
+    end
+
+    def serialize_key(k)
+      if k.to_s =~ /^[a-zA-Z_-]+[a-zA-Z0-9_-]*$/
+        k.to_s
+      else
+        sub(k, 2)
+      end
+    end
+
+    def serialize
+      case obj
+      when Hash
+        return SET_T.result(binding)
+      when Array
+        return LIST_T.result(binding)
+      when String
+        obj.dump
+      when Symbol
+        obj.to_s.dump
+      when Pathname
+        str = obj.to_s
+        if %r{/} !~ str
+          "./"+ str
+        else
+          str
+        end
+      when true, false
+        obj.to_s
+      else
+        fail "Cannot convert to nix: #{obj.inspect}"
+      end
+    end
+  end
+end

data/lib/bundix/shell_nix_context.rb

@@ -0,0 +1,27 @@
+class Bundix
+  class ShellNixContext < Struct.new(:project, :ruby, :gemfile, :lockfile, :gemset)
+    def self.from_hash(hash)
+      new(*hash.values_at(*members))
+    end
+
+    def bind
+      binding
+    end
+
+    def path_for(file)
+      Nixer.serialize(Pathname(file).relative_path_from(Pathname('./')))
+    end
+
+    def gemfile_path
+      path_for(gemfile)
+    end
+
+    def lockfile_path
+      path_for(lockfile)
+    end
+
+    def gemset_path
+      path_for(gemset)
+    end
+  end
+end

data/lib/bundix/source.rb

@@ -1,17 +1,5 @@
 class Bundix
-  class Source < Struct.new(:spec)
-    def convert
-      case spec.source
-      when Bundler::Source::Rubygems
-        convert_rubygems
-      when Bundler::Source::Git
-        convert_git
-      else
-        pp spec
-        fail 'unkown bundler source'
-      end
-    end
-
+  class Fetcher
     def sh(*args, &block)
       Bundix.sh(*args, &block)
     end
@@ -20,50 +8,95 @@ class Bundix
       warn "Downloading #{file} from #{url}"
       uri = URI(url)
       open_options = {}
-      if uri.user && uri.password
+
+      unless uri.user
+        inject_credentials_from_bundler_settings(uri)
+      end
+
+      if uri.user
         open_options[:http_basic_authentication] = [uri.user, uri.password]
         uri.user = nil
         uri.password = nil
       end
-      open(uri, 'r', 0600, open_options) do |net|
-        File.open(file, 'wb+') { |local|
-          File.copy_stream(net, local)
-        }
+
+      begin
+        open(uri.to_s, 'r', 0600, open_options) do |net|
+          File.open(file, 'wb+') { |local|
+            File.copy_stream(net, local)
+          }
+        end
+      rescue OpenURI::HTTPError => e
+        # e.message: "403 Forbidden" or "401 Unauthorized"
+        debrief_access_denied(uri.host) if e.message =~ /^40[13] /
+        raise
       end
     end
 
+    def inject_credentials_from_bundler_settings(uri)
+      @bundler_settings ||= Bundler::Settings.new(Bundler.root + '.bundle')
+
+      if val = @bundler_settings[uri.host]
+        uri.user, uri.password = val.split(':', 2)
+      end
+    end
+
+    def debrief_access_denied(host)
+      print_error(
+        "Authentication is required for #{host}.\n" +
+        "Please supply credentials for this source. You can do this by running:\n" +
+        " bundle config packages.shopify.io username:password"
+      )
+    end
+
+    def print_error(msg)
+      msg = "\x1b[31m#{msg}\x1b[0m" if $stdout.tty?
+      STDERR.puts(msg)
+    end
+
     def nix_prefetch_url(url)
-      dir = File.expand_path('~/.cache/bundix')
+      dir = File.join(ENV['XDG_CACHE_HOME'] || "#{ENV['HOME']}/.cache", 'bundix')
       FileUtils.mkdir_p dir
       file = File.join(dir, url.gsub(/[^\w-]+/, '_'))
 
-      unless File.size?(file)
-        download(file, url)
-      end
-
+      download(file, url) unless File.size?(file)
       return unless File.size?(file)
 
-      sh('nix-prefetch-url', '--type', 'sha256', "file://#{file}")
-        .force_encoding('UTF-8').strip
+      sh(
+        Bundix::NIX_PREFETCH_URL,
+        '--type', 'sha256',
+        '--name', File.basename(url), # --name mygem-1.2.3.gem
+        "file://#{file}",             # file:///.../https_rubygems_org_gems_mygem-1_2_3_gem
+      ).force_encoding('UTF-8').strip
     rescue => ex
       puts ex
       nil
     end
 
-    def nix_prefetch_git(uri, revision)
+    def nix_prefetch_git(uri, revision, submodules: false)
       home = ENV['HOME']
       ENV['HOME'] = '/homeless-shelter'
-      sh(NIX_PREFETCH_GIT, '--url', uri, '--rev', revision, '--hash', 'sha256', '--leave-dotGit')
+
+      args = []
+      args << '--url' << uri
+      args << '--rev' << revision
+      args << '--hash' << 'sha256'
+      args << '--fetch-submodules' if submodules
+
+      sh(NIX_PREFETCH_GIT, *args)
     ensure
       ENV['HOME'] = home
     end
 
+    def format_hash(hash)
+      sh(NIX_HASH, '--type', 'sha256', '--to-base32', hash)[SHA256_32]
+    end
+
     def fetch_local_hash(spec)
       spec.source.caches.each do |cache|
-        path = File.join(cache, "#{spec.name}-#{spec.version}.gem")
+        path = File.join(cache, "#{spec.full_name}.gem")
         next unless File.file?(path)
-        hash = nix_prefetch_url("file://#{path}")[SHA256_32]
-        return hash if hash
+        hash = nix_prefetch_url(path)[SHA256_32]
+        return format_hash(hash) if hash
       end
 
       nil
@@ -72,14 +105,14 @@ class Bundix
     def fetch_remotes_hash(spec, remotes)
       remotes.each do |remote|
         hash = fetch_remote_hash(spec, remote)
-        return remote, hash if hash
+        return remote, format_hash(hash) if hash
       end
 
       nil
     end
 
     def fetch_remote_hash(spec, remote)
-      uri = "#{remote}/gems/#{spec.name}-#{spec.version}.gem"
+      uri = "#{remote}/gems/#{spec.full_name}.gem"
       result = nix_prefetch_url(uri)
       return unless result
       result[SHA256_32]
@@ -88,14 +121,36 @@ class Bundix
       puts e.backtrace
       nil
     end
+  end
+
+  class Source < Struct.new(:spec, :fetcher)
+    def convert
+      case spec.source
+      when Bundler::Source::Rubygems
+        convert_rubygems
+      when Bundler::Source::Git
+        convert_git
+      when Bundler::Source::Path
+        convert_path
+      else
+        pp spec
+        fail 'unkown bundler source'
+      end
+    end
+
+    def convert_path
+      {
+        type: "path",
+        path: spec.source.path
+      }
+    end
 
     def convert_rubygems
       remotes = spec.source.remotes.map{|remote| remote.to_s.sub(/\/+$/, '') }
-      hash = fetch_local_hash(spec)
-      remote, hash = fetch_remotes_hash(spec, remotes) unless hash
-      fail "couldn't fetch hash for #{spec.name}-#{spec.version}" unless hash
-      hash = sh(NIX_HASH, '--type', 'sha256', '--to-base32', hash)[SHA256_32]
-      puts "#{hash} => #{spec.name}-#{spec.version}.gem" if $VERBOSE
+      hash = fetcher.fetch_local_hash(spec)
+      remote, hash = fetcher.fetch_remotes_hash(spec, remotes) unless hash
+      fail "couldn't fetch hash for #{spec.full_name}" unless hash
+      puts "#{hash} => #{spec.full_name}.gem" if $VERBOSE
 
       { type: 'gem',
         remotes: (remote ? [remote] : remotes),
@@ -105,17 +160,18 @@ class Bundix
     def convert_git
       revision = spec.source.options.fetch('revision')
       uri = spec.source.options.fetch('uri')
-      output = nix_prefetch_git(uri, revision)
+      submodules = !!spec.source.submodules
+      output = fetcher.nix_prefetch_git(uri, revision, submodules: submodules)
       # FIXME: this is a hack, we should separate $stdout/$stderr in the sh call
       hash = JSON.parse(output[/({[^}]+})\s*\z/m])['sha256']
-      fail "couldn't fetch hash for #{spec.name}-#{spec.version}" unless hash
+      fail "couldn't fetch hash for #{spec.full_name}" unless hash
       puts "#{hash} => #{uri}" if $VERBOSE
 
       { type: 'git',
         url: uri.to_s,
         rev: revision,
         sha256: hash,
-        fetchSubmodules: false }
+        fetchSubmodules: submodules }
     end
   end
 end

data/lib/bundix/version.rb

@@ -1,3 +1,3 @@
 class Bundix
-  VERSION = '2.3.0'
+  VERSION = '2.5.0'
 end

data/template/nixer/list.erb

@@ -0,0 +1 @@
+[<% obj.sort{|l,r| Nixer.order(l,r)}.each_with_index do |o, n|%><%if n > 0%> <%end%><%= sub(o) %><%end%>]

data/template/nixer/set.erb

@@ -0,0 +1,3 @@
+{
+<% obj.sort_by{|k,v| k.to_s.downcase}.each do |(k,v)| %><%= indent %><%= serialize_key(k) %> = <%= sub(v,2)%>;
+<%end%><%= outdent%>}

data/template/shell-nix.erb

@@ -0,0 +1,13 @@
+with (import <nixpkgs> {});
+let
+  env = bundlerEnv {
+    name = "<%= project %>-bundler-env";
+    inherit <%= ruby %>;
+    gemfile  = <%= gemfile_path %>;
+    lockfile = <%= lockfile_path %>;
+    gemset   = <%= gemset_path %>;
+  };
+in stdenv.mkDerivation {
+  name = "<%= project %>";
+  buildInputs = [ env ];
+}

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: bundix
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Michael 'manveru' Fellinger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-05 00:00:00.000000000 Z
+date: 2019-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
 description: Creates Nix packages from Gemfiles.
@@ -33,9 +33,14 @@ extra_rdoc_files: []
 files:
 - bin/bundix
 - lib/bundix.rb
-- lib/bundix/fetchurl-force.nix
+- lib/bundix/commandline.rb
+- lib/bundix/nixer.rb
+- lib/bundix/shell_nix_context.rb
 - lib/bundix/source.rb
 - lib/bundix/version.rb
+- template/nixer/list.erb
+- template/nixer/set.erb
+- template/shell-nix.erb
 homepage: https://github.com/manveru/bundix
 licenses:
 - MIT
@@ -56,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Creates Nix packages from Gemfiles.

data/lib/bundix/fetchurl-force.nix

@@ -1,27 +0,0 @@
-{ nixpkgs ? import <nixpkgs> {}
-, url
-}:
-        
-with nixpkgs;
-
-# (ab)use fetchurl to download a URL and add it to the nix store
-# *without* already knowing its hash.
-fetchurl {
-  inherit url;
-  sha256 = "0000000000000000000000000000000000000000000000000000";
-  downloadToTemp = true;
-  postFetch = ''
-    PATH="$PATH:${stdenv.lib.makeBinPath [ nix ]}"
-
-    sha256="$(nix-hash --base32 --type sha256 --flat "$downloadedFile")"
-    printf "%s\n" "$sha256"
-
-    file="$(dirname "$downloadedFile")/$(basename "$url")"
-    mv "$downloadedFile" "$file"
-    echo "adding to nix store..."
-    nix-store --add "$file"
-
-    echo "success! failing outer nix build..."
-    exit 1
-  '';
-}