Switch to BinaryProvider (#24)

Use GNU libiconv everywhere a usable iconv cannot be found. In particular,
this means we no longer use win-iconv on Windows, which allows relying on
a more consistent behavior across platforms.

Author: nalimilan

.travis.yml

@@ -4,8 +4,8 @@ os:
   - linux
   - osx
 julia:
-  - 0.5
   - 0.6
+  - 0.7
   - nightly
 notifications:
   email: false

README.md

@@ -5,10 +5,10 @@
 [![Coveralls Coverage Status](https://coveralls.io/repos/nalimilan/StringEncodings.jl/badge.svg?branch=master&service=github)](https://coveralls.io/github/nalimilan/StringEncodings.jl?branch=master)
 [![Codecov Coverage Status](http://codecov.io/github/nalimilan/StringEncodings.jl/coverage.svg?branch=master)](http://codecov.io/github/nalimilan/StringEncodings.jl?branch=master)
 
-[![Julia 0.5 Status](http://pkg.julialang.org/badges/StringEncodings_0.5.svg)](http://pkg.julialang.org/?pkg=StringEncodings&ver=0.5)
 [![Julia 0.6 Status](http://pkg.julialang.org/badges/StringEncodings_0.6.svg)](http://pkg.julialang.org/?pkg=StringEncodings&ver=0.6)
+[![Julia 0.7 Status](http://pkg.julialang.org/badges/StringEncodings_0.7.svg)](http://pkg.julialang.org/?pkg=StringEncodings&ver=0.7)
 
-This Julia package provides support for decoding and encoding texts between multiple character encodings. It is currently based on the iconv interface, and supports all major platforms (on Windows, it uses the native OS API via [win_iconv](https://github.com/win-iconv/win-iconv/)). In the future, native Julia support for major encodings will be added.
+This Julia package provides support for decoding and encoding texts between multiple character encodings. It is currently based on the iconv interface, and supports all major platforms using either the native iconv support or [GNU libiconv](https://www.gnu.org/software/libiconv/). In the future, native Julia support for major encodings will be added.
 
 ## Encoding and Decoding Strings
 *Encoding* a refers to the process of converting a string (of any `AbstractString` type) to a sequence of bytes represented as a `Vector{UInt8}`. *Decoding* refers to the inverse process.

REQUIRE

@@ -1,5 +1,4 @@
-julia 0.5
-BinDeps
+julia 0.6
+BinaryProvider 0.3.0
 Compat 0.17.0
-@windows WinRPM
 LegacyStrings 0.1.1

appveyor.yml

@@ -1,9 +1,9 @@
 environment:
   matrix:
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.5/julia-0.5-latest-win32.exe"
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.5/julia-0.5-latest-win64.exe"
   - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
   - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.7/julia-0.7-latest-win32.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.7/julia-0.7-latest-win64.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
 

deps/build.jl

@@ -1,17 +1,15 @@
-using BinDeps
-
-@BinDeps.setup
-
 # Check for an iconv implementation with the GNU (non-POSIX) behavior:
 # EILSEQ is returned when a sequence cannot be converted to target encoding,
 # instead of succeeding and only returning the number of invalid conversions
 # This non-standard behavior is required to allow replacing invalid sequences
 # with a user-defined character.
 # Implementations with this behavior include glibc, GNU libiconv (on which Mac
 # OS X's is based) and win_iconv.
-function validate_iconv(n, h)
+function validate_iconv(lib, iconv_open, iconv_close, iconv)
+    h = Libdl.dlopen_e(lib)
+    h == C_NULL && return false
     # Needed to check libc
-    f = Libdl.dlsym_e(h, "iconv_open")
+    f = Libdl.dlsym_e(h, iconv_open)
     f == C_NULL && return false
 
     cd = ccall(f, Ptr{Void}, (Cstring, Cstring), "ASCII", "UTF-8")
@@ -23,31 +21,103 @@ function validate_iconv(n, h)
     inbytesleft = Ref{Csize_t}(sizeof(s))
     outbufptr = Ref{Ptr{UInt8}}(pointer(a))
     outbytesleft = Ref{Csize_t}(length(a))
-    ret = ccall(Libdl.dlsym_e(h, "iconv"), Csize_t,
+    ret = ccall(Libdl.dlsym_e(h, iconv), Csize_t,
                 (Ptr{Void}, Ptr{Ptr{UInt8}}, Ref{Csize_t}, Ptr{Ptr{UInt8}}, Ref{Csize_t}),
                 cd, inbufptr, inbytesleft, outbufptr, outbytesleft)
-    ccall(Libdl.dlsym_e(h, "iconv_close"), Void, (Ptr{Void},), cd) == -1 && return false
+    ccall(Libdl.dlsym_e(h, iconv_close), Void, (Ptr{Void},), cd) == -1 && return false
 
     return ret == -1 % Csize_t && Libc.errno() == Libc.EILSEQ
 end
 
-libiconv = library_dependency("libiconv", aliases = ["libc", "libc-bin", "iconv"],
-                              validate = validate_iconv)
+using BinaryProvider
+
+# Parse some basic command-line arguments
+const verbose = "--verbose" in ARGS
+const prefix = Prefix(get([a for a in ARGS if a != "--verbose"], 1, joinpath(@__DIR__, "usr")))
+products = [
+    LibraryProduct(prefix, String["libiconv"], :libiconv)
+]
+
+# Download binaries from hosted location
+bin_prefix = "https://github.com/JuliaStrings/IConvBuilder/releases/download/v1.15+build.2"
 
-if is_windows()
-    using WinRPM
-    provides(WinRPM.RPM, "win_iconv-dll", libiconv, os = :Windows)
+# Listing of files generated by BinaryBuilder:
+download_info = Dict(
+    BinaryProvider.Linux(:aarch64, :glibc, :blank_abi) => ("$bin_prefix/IConv.aarch64-linux-gnu.tar.gz", "3e6a353988e5089c7b49fb79350d90c31475c10c3d7c1271f889889db53d307f"),
+    BinaryProvider.Linux(:aarch64, :musl, :blank_abi) => ("$bin_prefix/IConv.aarch64-linux-musl.tar.gz", "2dc859f220a7df89b68e31a1e772a461e288e5b4691ccb2fc76ec0b1e828b98a"),
+    BinaryProvider.Linux(:armv7l, :glibc, :eabihf) => ("$bin_prefix/IConv.arm-linux-gnueabihf.tar.gz", "43900a0baaaf7b43f8c67ec022bb488cae4972acb958562cfc533294a3acf93e"),
+    BinaryProvider.Linux(:armv7l, :musl, :eabihf) => ("$bin_prefix/IConv.arm-linux-musleabihf.tar.gz", "2547a615f078af1a877447a06717337bf1588bc7e81d19163b73905902681fe0"),
+    BinaryProvider.Linux(:i686, :glibc, :blank_abi) => ("$bin_prefix/IConv.i686-linux-gnu.tar.gz", "b7af0081f0d0f5be0020053d811d7dc2d2f1d0349009a0258c19319a2835c490"),
+    BinaryProvider.Linux(:i686, :musl, :blank_abi) => ("$bin_prefix/IConv.i686-linux-musl.tar.gz", "a3e6869733ec511e2e45347607515cdf05b92b48dfbd5c3cb5e47bdf78cfe4cd"),
+    BinaryProvider.Windows(:i686, :blank_libc, :blank_abi) => ("$bin_prefix/IConv.i686-w64-mingw32.tar.gz", "247cc617fbc0e059943d905e068171479e1a354c6b59b8a298bfda98ec0230f5"),
+    BinaryProvider.Linux(:powerpc64le, :glibc, :blank_abi) => ("$bin_prefix/IConv.powerpc64le-linux-gnu.tar.gz", "62bee599a09dfb98e0d410fd93d30188cb0472295f25b9cc05e31dda35904ab8"),
+    BinaryProvider.MacOS(:x86_64, :blank_libc, :blank_abi) => ("$bin_prefix/IConv.x86_64-apple-darwin14.tar.gz", "1489b867362c1ee6daa8e16361daa7f9d9613a67cb684d1eb8b93b3d74137188"),
+    BinaryProvider.Linux(:x86_64, :glibc, :blank_abi) => ("$bin_prefix/IConv.x86_64-linux-gnu.tar.gz", "a61ec482c81bca8c1fb3108908481c14d61668fa11b5ef0498badad2119559e5"),
+    BinaryProvider.Linux(:x86_64, :musl, :blank_abi) => ("$bin_prefix/IConv.x86_64-linux-musl.tar.gz", "75d2b2e02e0ca3cb6efe38be071556d222c7d5a0755c077717eea6391870832f"),
+    BinaryProvider.FreeBSD(:x86_64, :blank_libc, :blank_abi) => ("$bin_prefix/IConv.x86_64-unknown-freebsd11.1.tar.gz", "144e7e0f6d66178e357f5279a04a92b4aa50051a6061f0eec06045d63dd283f4"),
+    BinaryProvider.Windows(:x86_64, :blank_libc, :blank_abi) => ("$bin_prefix/IConv.x86_64-w64-mingw32.tar.gz", "e7840895294b82bbacbf1002aa6b3a739b68de31e119c177126a6da5fe7ff227"),
+)
+
+# Detect already present libc iconv or libiconv
+# (notably for Linux, Mac OS and other Unixes)
+found_iconv = false
+for lib in ("libc", "libc-bin", "libiconv", "iconv")
+    if lib in ("libc", "libc-bin")
+        global iconv_open = :iconv_open
+        global iconv_close = :iconv_close
+        global iconv = :iconv
+    else
+        global iconv_open =  :libiconv_open
+        global iconv_close = :libiconv_close
+        global iconv = :libiconv
+    end
+    if validate_iconv(lib, iconv_open, iconv_close, iconv)
+        found_iconv = true
+        write(joinpath(@__DIR__, "deps.jl"),
+              """
+              ## This file autogenerated by Pkg.build(\\"StringEncodings\\").
+              ## Do not edit.
+              const libiconv = "$lib"
+              function check_deps()
+                  global libiconv
+                  if Libdl.dlopen_e(libiconv) == C_NULL
+                      error("\$(libiconv) cannot be opened. Please re-run Pkg.build(\\"StringEncodings\\"), and restart Julia.")
+                  end
+
+              end
+              """)
+        break
+    end
 end
 
-provides(Sources,
-         URI("http://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.15.tar.gz"),
-         libiconv,
-         SHA="ccf536620a45458d26ba83887a983b96827001e92a13847b45e4925cc8913178")
+if !found_iconv
+    iconv_open =  :libiconv_open
+    iconv_close = :libiconv_close
+    iconv = :libiconv
+    # Install unsatisfied or updated dependencies:
+    unsatisfied = any(!satisfied(p; verbose=verbose) for p in products)
+    if haskey(download_info, platform_key())
+        url, tarball_hash = download_info[platform_key()]
+        if unsatisfied || !isinstalled(url, tarball_hash; prefix=prefix)
+            # Download and install binaries
+            install(url, tarball_hash; prefix=prefix, force=true, verbose=verbose)
+        end
+    elseif unsatisfied
+        # If we don't have a BinaryProvider-compatible .tar.gz to download, complain.
+        # Alternatively, you could attempt to install from a separate provider,
+        # build from source or something even more ambitious here.
+        error("Your platform $(triplet(platform_key())) is not supported by this package! Try installing libiconv manually.")
+    end
 
-provides(BuildProcess,
-         Autotools(libtarget = "lib/libiconv.la",
-                   installed_libname = "libiconv"*BinDeps.shlib_ext),
-         libiconv,
-         os = :Unix)
+    # Write out a deps.jl file that will contain mappings for our products
+    write_deps_file(joinpath(@__DIR__, "deps.jl"), products)
+end
 
-@BinDeps.install Dict(:libiconv => :libiconv)
+open(joinpath(@__DIR__, "deps.jl"), "a") do io
+    write(io,
+          """
+          const iconv_open_s = :$iconv_open
+          const iconv_close_s = :$iconv_close
+          const iconv_s = :$iconv
+          """)
+end

src/StringEncodings.jl

@@ -1,6 +1,20 @@
 # This file is a part of StringEncodings.jl. License is MIT: http://julialang.org/license
 
 module StringEncodings
+
+# Load in `deps.jl`, complaining if it does not exist
+const depsjl_path = joinpath(dirname(@__FILE__), "..", "deps", "deps.jl")
+if !isfile(depsjl_path)
+    error("iconv not installed properly, run Pkg.build(\"StringEncodings\"), restart Julia and try again")
+end
+include(depsjl_path)
+
+# Module initialization function
+function __init__()
+    # Always check dependencies from `deps.jl`
+    check_deps()
+end
+
 using Base.Libc: errno, strerror, E2BIG, EINVAL, EILSEQ
 using Compat: @compat
 
@@ -56,21 +70,18 @@ end
 show{T<:Union{IncompleteSequenceError,OutputBufferError}}(io::IO, exc::T) =
     print(io, message(T))
 
-depsjl = joinpath(dirname(@__FILE__), "..", "deps", "deps.jl")
-isfile(depsjl) ? include(depsjl) : error("libiconv not properly installed. Please run\nPkg.build(\"StringEncodings\")")
-
 
 ## iconv wrappers
 
 function iconv_close(cd::Ptr{Void})
     if cd != C_NULL
-        ccall((:iconv_close, libiconv), Cint, (Ptr{Void},), cd) == 0 ||
+        ccall((iconv_close_s, libiconv), Cint, (Ptr{Void},), cd) == 0 ||
             throw(IConvError("iconv_close"))
     end
 end
 
 function iconv_open(tocode::String, fromcode::String)
-    p = ccall((:iconv_open, libiconv), Ptr{Void}, (Cstring, Cstring), tocode, fromcode)
+    p = ccall((iconv_open_s, libiconv), Ptr{Void}, (Cstring, Cstring), tocode, fromcode)
     if p != Ptr{Void}(-1)
         return p
     elseif errno() == EINVAL
@@ -133,7 +144,7 @@ function iconv!(cd::Ptr{Void}, inbuf::Vector{UInt8}, outbuf::Vector{UInt8},
     inbytesleft_orig = inbytesleft[]
     outbytesleft[] = BUFSIZE
 
-    ret = ccall((:iconv, libiconv), Csize_t,
+    ret = ccall((iconv_s, libiconv), Csize_t,
                 (Ptr{Void}, Ptr{Ptr{UInt8}}, Ref{Csize_t}, Ptr{Ptr{UInt8}}, Ref{Csize_t}),
                 cd, inbufptr, inbytesleft, outbufptr, outbytesleft)
 
@@ -165,7 +176,7 @@ function iconv_reset!(s::Union{StringEncoder, StringDecoder})
 
     s.outbufptr[] = pointer(s.outbuf)
     s.outbytesleft[] = BUFSIZE
-    ret = ccall((:iconv, libiconv), Csize_t,
+    ret = ccall((iconv_s, libiconv), Csize_t,
                 (Ptr{Void}, Ptr{Ptr{UInt8}}, Ref{Csize_t}, Ptr{Ptr{UInt8}}, Ref{Csize_t}),
                 s.cd, C_NULL, C_NULL, s.outbufptr, s.outbytesleft)
 
@@ -506,7 +517,7 @@ encode(s::AbstractString, enc::AbstractString) = encode(s, Encoding(enc))
 
 function test_encoding(enc::String)
     # We assume that an encoding is supported if it's possible to convert from it to UTF-8:
-    cd = ccall((:iconv_open, libiconv), Ptr{Void}, (Cstring, Cstring), enc, "UTF-8")
+    cd = ccall((iconv_open_s, libiconv), Ptr{Void}, (Cstring, Cstring), enc, "UTF-8")
     if cd == Ptr{Void}(-1)
         return false
     else