licensed 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3baec95cfc92e05345d639e02f55185da93a50a2
-  data.tar.gz: 7b970c9ea7bfe7c0724fde3d75ea058011655554
+  metadata.gz: b1d1f0def7d120443e89895960f41bb7dd90a63f
+  data.tar.gz: 951687b4ab3804df152f6dbbbfd4ffd2db3e3c71
 SHA512:
-  metadata.gz: bab9dbb1f74d2658cf93f689b4f828a40666836c444b35ca4999a8265cd5f471a60fc0b93a53008130148f8d7ee6f69bc8701a31961eba99d967b28566aae793
-  data.tar.gz: 74920ce7597d046570c5f45e9bd4c341ddebdf0958a8059eb1f43015209a1d69d54a498e2d0ec4ee838fb074e27bad2f1c9ba181b18dda2c8f9992265a92dc67
+  metadata.gz: b7ca6dc13ebb771ed191e36fde4ab7c75aaadd1ca2e406a925595f3ee98553f660a8d81c677a2d87c346c0bfb32b8693e07cf90f8c5b6e0a817f368326d5f262
+  data.tar.gz: '0197b0088dd379120614fb725efd41a58d3eed9744e32928220ecb431d63f8be5229888f1857e1ef2b5a3cbfc7810524b10b33c84c71a9990000c26f7f7bb912'

data/CHANGELOG.md

@@ -6,6 +6,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## 1.2.0 - 2018-06-22
+### Added
+- Building and packaging distributable exes for licensed releases
+- Can now configure which Gemfile groups are excluded from dependency enumeration
+
+### Fixed
+- Bundler is no longer always reported as a dependency
+- Set the minimum required ruby version for licensed
+
 ## 1.1.0 - 2018-06-04
 ### Added
 - Pip dependency source :tada:
@@ -36,4 +45,4 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 Initial release :tada:
 
-[Unreleased]: https://github.com/github/licensed/compare/v1.0.1...HEAD
+[Unreleased]: https://github.com/github/licensed/compare/1.2.0...HEAD

data/CONTRIBUTING.md

@@ -40,8 +40,8 @@ Pull requests that include a new dependency source must also
 If you are the current maintainer of this gem:
 
 1. Create a branch for the release: git checkout -b cut-release-vxx.xx.xx
-2. Make sure your local dependencies are up to date: script/bootstrap
-3. Ensure that tests are green: bundle exec rake test
+2. Make sure your local dependencies are up to date: `script/bootstrap`
+3. Ensure that tests are green: `bundle exec rake test`
 4. Bump gem version in lib/licensed/version.rb.
 5. Update [`CHANGELOG.md`](CHANGELOG.md)
 6. Make a PR to github/licensed.
@@ -51,8 +51,11 @@ If you are the current maintainer of this gem:
    2. Install the new gem locally
    3. Test behavior locally, branch deploy, whatever needs to happen
 9. Merge github/licensed PR
-10. Tag and push: git tag vx.xx.xx; git push --tags
-11. Push to rubygems.org -- gem push licensed-x.xx.xx.gem
+10. Tag and push: `git tag x.xx.xx; git push --tags`
+11. Push to rubygems.org -- `gem push licensed-x.xx.xx.gem`
+12. Build packages for new tag: `VERSION=x.xx.xx bundle exec rake package`
+13. Create release for new tag at github/licensed.
+14. Add built packages to new release
 
 ## Resources
 

data/README.md

@@ -118,6 +118,10 @@ if Licensed::Shell.tool_available?('bundle')
 end
 ```
 
+## Packaging
+
+Licensed can be built into an exe and packaged for distribution to systems that don't have ruby already available.  See the [packaging documentation](./docs/packaging.md) for details.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/github/licensed. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org/) code of conduct.  See [CONTRIBUTING](CONTRIBUTING.md) for more details.

data/Rakefile

@@ -47,7 +47,8 @@ namespace :test do
 
       # use negative lookahead to exclude all source tests except
       # the tests for `source`
-      t.test_files = FileList["test/**/*_test.rb"].exclude(/test\/source\/(?!#{source}).*?_test.rb/)
+      t.test_files = FileList["test/**/*_test.rb"].exclude(/test\/source\/(?!#{source}).*?_test.rb/,
+                                                           "test/fixtures/**/*_test.rb")
     end
   end
 end
@@ -55,9 +56,34 @@ end
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.test_files = FileList["test/**/*_test.rb"].exclude("test/fixtures/**/*_test.rb")
 end
 
+packages_search = File.expand_path("script/packages/*", __dir__)
+platforms = Dir[packages_search].map { |f| File.basename(f, ".*") }
+
+namespace :package do
+  platforms.each do |platform|
+    desc "Package licensed for #{platform}"
+    task platform.to_sym do
+      puts "Packaging licensed for #{platform}"
+
+      if Bundler.with_original_env { system("script/packages/#{platform}") }
+        # green
+        puts "\033[32mCompleted packaging for #{platform}.\e[0m"
+      else
+        # red
+        puts "\033[31mEncountered an error packaging for #{platform}.\e[0m"
+      end
+
+      puts
+    end
+  end
+end
+
+desc "Package licensed for all platforms"
+task package: platforms.map { |platform| "package:#{platform}" }
+
 # add rubocop task
 # -S adds styleguide urls to offense messages
 RuboCop::RakeTask.new do |t|

data/docker/Dockerfile.build-linux

@@ -0,0 +1,11 @@
+FROM ruby:2.4-slim-stretch
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends cmake make gcc pkg-config squashfs-tools git curl bison \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN curl -L http://enclose.io/rubyc/rubyc-linux-x64.gz | gunzip > /usr/local/bin/rubyc \
+    && chmod +x /usr/local/bin/rubyc
+
+ENV CPPFLAGS="-P"
+ENV RUBYC="/usr/local/bin/rubyc"

data/docs/packaging.md

@@ -0,0 +1,53 @@
+# Packaging licensed for distribution
+
+Licensed is built into executables and packaged for distribution using [ruby-packer][ruby-packer].
+
+Executable packages are currently supported for:
+1. Linux
+2. MacOS / Darwin
+
+The packaged executables contain a self-expanding file system containing ruby, licensed and all of it's runtime dependencies.  Licensed is run inside the contained file system, allowing usage in scenarios where ruby is not available on the host system.
+
+### Building packages
+
+Packages are built as `licensed-$VERSION-$PLATFORM-x64.tar.gz` tarballs that contain a single `./licensed` executable.  After building a package through the available scripting, it will be available in the `pkg` directory.
+
+By default an exe is built for the current licensed git `HEAD`.  The
+`$VERSION` in the package name will be set to the current branch name if
+available, otherwise the current SHA.  To use a specific licensed version,
+set a `VERSION` environment variable when calling the packaging scripts.  `VERSION` can be set to any value that works with `git checkout`.
+
+#### Building all packages
+```bash
+# build all packages
+$ script/package
+```
+or
+```bash
+# build all packages
+$ bundle exec rake package
+```
+
+#### Building packages for a single platform
+```bash
+# build package for linux
+$ script/package linux
+```
+or
+```bash
+# build package for linux
+$ bundle exec rake package:linux
+```
+
+#### Building packages for a specific version
+```bash
+# VERSION can be set to anything that works with git checkout - tag, branch, SHA1
+$ VERSION="1.1.0" script/package
+```
+or
+```bash
+# VERSION can be set to anything that works with git checkout - tag, branch, SHA1
+$ VERSION="1.1.0" bundle exec rake package
+```
+
+[ruby-packer]: https://github.com/pmq20/ruby-packer

data/docs/sources/bundler.md

@@ -2,6 +2,29 @@
 
 The bundler source will detect dependencies `Gemfile` and `Gemfile.lock` files are found at an apps `source_path`.  The source uses the `Bundler` API to enumerate dependencies from `Gemfile` and `Gemfile.lock`.
 
-The bundler source will exclude gems in the `:development` and `:test` groups.  Be aware that if you have a local
-bundler configuration (e.g. `.bundle`), that configuration will be respected as well.  For example, if you have a local
-configuration set for `without: [':server']`, the bundler source will exclude all gems in the `:server` group.
+### Excluding gem groups
+
+The bundler source determines which gem groups to include or exclude with the following logic, in order of precedence.
+1. Include all groups specified in the Gemfile
+2. Exclude all groups from the `without` bundler configuration (e.g. `.bundle/config`)
+3. Include all groups from the `with` bundler configuration (e.g. `.bundle/config`)
+4. Exclude all groups from the `without` licensed configuration (`:development` and `:test` if not otherwise specified)
+
+`licensed` can be configured to override the default "without" development and test groups in the configuration file.
+
+Strings and string arrays are both :+1:
+
+```yml
+rubygems:
+  without: development
+```
+
+or
+
+```yml
+rubygems:
+  without:
+    - build
+    - development
+    - test
+```

data/docs/sources/dep.md

@@ -3,17 +3,9 @@ This source is intended to be used when all of a projects dependencies have been
 
 # Go Dep
 
-The dep source will detect dependencies when the source is enabled and both `Gopkg.toml` and `Gopkg.lock` are found at an apps `source_path`.  It
+The dep source will detect dependencies when the source is enabled and `Gopkg.lock` is found at an apps `source_path`.  It
 parses the `Gopkg.lock` file to find packages that have been vendored into the project directory.
 
-This source will self-disable if the `ignored` property in `Gopkg.toml` has any values.  While strongly discouraged, the source can be forced to run
-via configuration.
-
-```yml
-dep:
-  allow_ignored: true # force source to run even if `Gopkg.toml` is non-empty
-```
-
 #### Limitations
 
 The dep dependency source has some limitations compared to the general-purpose go source.

data/lib/licensed/shell.rb

@@ -6,8 +6,8 @@ module Licensed
     # Executes a command, returning its standard output on success. On failure,
     # it raises an exception that contains the error output, unless
     # `allow_failure` is true, in which case it returns an empty string.
-    def self.execute(cmd, *args, allow_failure: false)
-      stdout, stderr, status = Open3.capture3(cmd, *args)
+    def self.execute(cmd, *args, allow_failure: false, env: {})
+      stdout, stderr, status = Open3.capture3(env, cmd, *args)
 
       if status.success?
         stdout.strip

data/lib/licensed/source/bundler.rb

@@ -8,6 +8,7 @@ module Licensed
   module Source
     class Bundler
       GEMFILES = %w{Gemfile gems.rb}.freeze
+      DEFAULT_WITHOUT_GROUPS = %i{development test}
 
       def self.type
         "rubygem"
@@ -23,8 +24,8 @@ module Licensed
 
       def dependencies
         @dependencies ||= with_local_configuration do
-          definition.specs_for(groups).map do |spec|
-            Dependency.new(spec.gem_dir, {
+          specs.map do |spec|
+            Licensed::Dependency.new(spec.gem_dir, {
               "type"     => Bundler.type,
               "name"     => spec.name,
               "version"  => spec.version.to_s,
@@ -35,14 +36,139 @@ module Licensed
         end
       end
 
+      # Returns an array of Gem::Specifications for all gem dependencies
+      def specs
+        # get the specifications for all dependencies in a Gemfile
+        root_dependencies = definition.dependencies.select { |d| include?(d, nil) }
+        root_specs = specs_for_dependencies(root_dependencies, nil).compact
+
+        # recursively find the remaining specifications
+        all_specs = recursive_specs(root_specs)
+
+        # delete any specifications loaded from a gemspec
+        all_specs.delete_if { |s| s.source.is_a?(::Bundler::Source::Gemspec) }
+      end
+
+      # Recursively finds the dependencies for Gem specifications.
+      # Returns a `Set` containing the package names for all dependencies
+      def recursive_specs(specs, results = Set.new)
+        return [] if specs.nil? || specs.empty?
+
+        new_specs = Set.new(specs) - results.to_a
+        return [] if new_specs.empty?
+
+        results.merge new_specs
+
+        dependency_specs = new_specs.flat_map { |s| specs_for_dependencies(s.dependencies, s.source) }
+
+        return results if dependency_specs.empty?
+
+        results.merge recursive_specs(dependency_specs, results)
+      end
+
+      # Returns the specs for dependencies that pass the checks in `include?`
+      # Raises an error if the specification isn't found
+      def specs_for_dependencies(dependencies, source)
+        included_dependencies = dependencies.select { |d| include?(d, source) }
+        included_dependencies.map do |dep|
+          gem_spec(dep) || raise("Unable to find a specification for #{dep.name} (#{dep.requirement}) in any sources")
+        end
+      end
+
+      # Returns a Gem::Specification for the provided gem argument.  If a
+      # Gem::Specification isn't found, an error will be raised.
+      def gem_spec(dependency)
+        return unless dependency
+
+        # bundler specifications aren't put in ::Bundler.specs_path, even if the
+        # gem is a runtime dependency.  it needs to be handled specially
+        return bundler_spec if dependency.name == "bundler"
+
+        # find a specifiction from the resolved ::Bundler::Definition specs
+        spec = definition.resolve.find { |s| s.satisfies?(dependency) }
+        return spec unless spec.is_a?(::Bundler::LazySpecification)
+
+        # if the specification is coming from a gemspec source,
+        # we can get a non-lazy specification straight from the source
+        if spec.source.is_a?(::Bundler::Source::Gemspec)
+          return spec.source.specs.first
+        end
+
+        # look for a specification at the bundler specs path
+        spec_path = ::Bundler.specs_path.join("#{spec.full_name}.gemspec")
+        return unless File.exist?(spec_path.to_s)
+        Gem::Specification.load(spec_path.to_s)
+      end
+
+      # Returns whether a dependency should be included in the final
+      def include?(dependency, source)
+        # ::Bundler::Dependency has an extra `should_include?`
+        return false unless dependency.should_include? if dependency.respond_to?(:should_include?)
+
+        # Don't return gems added from `add_development_dependency` in a gemspec
+        # if the :development group is excluded
+        gemspec_source = source.is_a?(::Bundler::Source::Gemspec)
+        return false if dependency.type == :development && (!gemspec_source || exclude_development_dependencies?)
+
+        # Gem::Dependency don't have groups - in our usage these objects always
+        # come as child-dependencies and are never directly from a Gemfile.
+        # We assume that all Gem::Dependencies are ok at this point
+        return true if dependency.groups.nil?
+
+        # check if the dependency is in any groups we're interested in
+        (dependency.groups & groups).any?
+      end
+
+      # Returns whether development dependencies should be excluded
+      def exclude_development_dependencies?
+        @include_development ||= begin
+          # check whether the development dependency group is explicitly removed
+          # or added via bundler and licensed configurations
+          groups = [:development] - Array(::Bundler.settings[:without]) + Array(::Bundler.settings[:with]) - exclude_groups
+          !groups.include?(:development)
+        end
+      end
+
+      # Returns a gemspec for bundler, found and loaded by running `gem specification bundler`
+      # This is a hack to work around bundler not placing it's own spec at
+      # `::Bundler.specs_path` when it's an explicit dependency
+      def bundler_spec
+        # cache this so we run CLI commands as few times as possible
+        return @bundler_spec if defined?(@bundler_spec)
+
+        # finding the bundler gem is dependent on having `gem` available
+        unless Licensed::Shell.tool_available?("gem")
+          @bundler_spec = nil
+          return
+        end
+
+        # Bundler is always used from the default gem install location.
+        # we can use `gem specification bundler` with a clean ENV to
+        # get the system bundler gem as YAML
+        yaml = ::Bundler.with_original_env { Licensed::Shell.execute("gem", "specification", "bundler") }
+        @bundler_spec = Gem::Specification.from_yaml(yaml)
+      end
+
       # Build the bundler definition
       def definition
         @definition ||= ::Bundler::Definition.build(gemfile_path, lockfile_path, nil)
       end
 
-      # Returns the bundle definition groups, excluding test and development
+      # Returns the bundle definition groups, removing "without" groups,
+      # and including "with" groups
       def groups
-        definition.groups - [:test, :development]
+        definition.groups - Array(::Bundler.settings[:without]) + Array(::Bundler.settings[:with]) - exclude_groups
+      end
+
+      # Returns any groups to exclude specified from both licensed configuration
+      # and bundler configuration.
+      # Defaults to [:development, :test] + ::Bundler.settings[:without]
+      def exclude_groups
+        @exclude_groups ||= begin
+          exclude = Array(@config.dig("rubygems", "without"))
+          exclude.push(*DEFAULT_WITHOUT_GROUPS) if exclude.empty?
+          exclude.uniq.map(&:to_sym)
+        end
       end
 
       # Returns the path to the Bundler Gemfile
@@ -61,20 +187,15 @@ module Licensed
 
       # helper to clear all bundler environment around a yielded block
       def with_local_configuration
-        original_bundle_gemfile = ENV["BUNDLE_GEMFILE"]
-
-        # with a clean, original environment
-        ::Bundler.with_original_env do
-          # force bundler to use the local gem file
-          ENV["BUNDLE_GEMFILE"] = gemfile_path.to_s
+        # force bundler to use the local gem file
+        original_bundle_gemfile, ENV["BUNDLE_GEMFILE"] = ENV["BUNDLE_GEMFILE"], gemfile_path.to_s
 
-          # reset all bundler configuration
-          ::Bundler.reset!
-          # and re-configure with settings for current directory
-          ::Bundler.configure
+        # reset all bundler configuration
+        ::Bundler.reset!
+        # and re-configure with settings for current directory
+        ::Bundler.configure
 
-          yield
-        end
+        yield
       ensure
         ENV["BUNDLE_GEMFILE"] = original_bundle_gemfile
         # restore bundler configuration

data/lib/licensed/source/dep.rb

@@ -60,21 +60,13 @@ module Licensed
       end
 
       def go_dep_available?
-        return false unless gopkg_lock_path.exist? && gopkg_toml_path.exist?
-        return true if @config.dig("dep", "allow_ignored") == true
-
-        gopkg_toml = Tomlrb.load_file(gopkg_toml_path, symbolize_keys: true)
-        gopkg_toml[:ignored].nil? || gopkg_toml[:ignored].empty?
+        gopkg_lock_path.exist?
       end
 
       def gopkg_lock_path
         @config.pwd.join("Gopkg.lock")
       end
 
-      def gopkg_toml_path
-        @config.pwd.join("Gopkg.toml")
-      end
-
       # Returns a list of go standard packages
       def go_std_packages
         @std_packages ||= begin

data/lib/licensed/source/pip.rb

@@ -14,6 +14,7 @@ module Licensed
       end
 
       def enabled?
+        return unless virtual_env_pip && Licensed::Shell.tool_available?(virtual_env_pip)
         File.exist?(@config.pwd.join("requirements.txt"))
       end
 
@@ -50,13 +51,20 @@ module Licensed
       end
 
       def pip_command(*args)
-        venv_dir = @config.dig("python", "virtual_env_dir")
-        if venv_dir.nil?
-          raise "Virtual env directory not set."
+        Licensed::Shell.execute(virtual_env_pip, "--disable-pip-version-check", "show", *args)
+      end
+
+      def virtual_env_pip
+        return unless virtual_env_dir
+        File.join(virtual_env_dir, "bin", "pip")
+      end
+
+      def virtual_env_dir
+        return @virtual_env_dir if defined?(@virtual_env_dir)
+        @virtual_env_dir = begin
+          venv_dir = @config.dig("python", "virtual_env_dir")
+          File.expand_path(venv_dir, Licensed::Git.repository_root) if venv_dir
         end
-        venv_dir = File.expand_path(venv_dir, Licensed::Git.repository_root)
-        pip = File.join(venv_dir, "bin", "pip")
-        Licensed::Shell.execute(pip, "--disable-pip-version-check", "show", *args)
       end
     end
   end

data/lib/licensed/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Licensed
-  VERSION = "1.1.0".freeze
+  VERSION = "1.2.0".freeze
 end

data/licensed.gemspec

@@ -21,18 +21,20 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = ">= 2.3.0"
+
   spec.add_dependency "licensee", "~> 9.0"
   spec.add_dependency "thor", "~>0.19"
   spec.add_dependency "octokit", "~>4.0"
   spec.add_dependency "pathname-common_prefix", "~>0.0.1"
   spec.add_dependency "tomlrb", "~>1.2"
+  spec.add_dependency "bundler", "~> 1.10"
 
-  spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.8"
   spec.add_development_dependency "vcr", "~> 2.9"
   spec.add_development_dependency "webmock", "~> 1.21"
   spec.add_development_dependency "rubocop", "~> 0.49"
   spec.add_development_dependency "rubocop-github", "~> 0.6"
-  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "byebug", "~> 10.0.0"
 end

data/script/build-rubyc-exe

@@ -0,0 +1,58 @@
+#!/bin/bash
+#/ Usage: script/build-rubyc-exe <RUBYC> [VERSION]
+#/
+#/ WARNING: You should not need to call this directly. Please create packages using
+#/ `script/package [platform]` or `bundle exec rake package[platform]`
+#/
+#/ Builds a distributable package for licensed for a given RUBYC compiler and licensed VERSION.
+#/ Packages are of the form licensed-$VERSION-$PLATFORM-x64.tar.gz and contain a `./licensed` executable
+#/ Built Packages are placed in the <root>/pkg directory.
+#/
+#/ OPTIONS:
+#/   <RUBYC>           The path to a rubyc compiler that should be used to compile the target executable
+#/   [VERSION]         (optional, default to current git branch or SHA1) version of licensed to build exe at
+#/
+#/ EXAMPLES:
+#/
+#/   Builds a package for version 1.1.0 using a local rubyc compiler
+#/     $ build-rubyc-exe RUBYC="./rubyc-darwin" VERSION="1.1.0"
+#/
+
+set -euo pipefail
+
+usage(){
+  grep "^#/" <"$0" | cut -c3-
+}
+
+BASE_DIR="$(cd "$(dirname $0)/.." && pwd)"
+VERSION=${VERSION:=""}
+RUBYC=${RUBYC:=""}
+if [ ! -f "$RUBYC" ]; then
+  echo "Please specify a rubyc compiler" >&2
+  usage
+  exit 127
+fi
+
+BUILD_DEST="$(mktemp -d)"
+trap "rm -rf $BUILD_DEST" EXIT
+
+if [ -n "$VERSION" ]; then
+  git checkout "$VERSION"
+  CURRENT_BRANCH="$(git rev-parse --abbrev-ref HEAD)"
+  trap "rm -rf $BUILD_DEST; git checkout $CURRENT_BRANCH" EXIT
+else
+  VERSION="$(git rev-parse --abbrev-ref HEAD)"
+fi
+
+PACKAGE_DEST="$BASE_DIR/pkg"
+mkdir -p "$PACKAGE_DEST"
+
+PLATFORM="$(uname -s | tr '[:upper:]' '[:lower:]')"
+TARGET="licensed-$VERSION-$PLATFORM-x64.tar.gz"
+
+"$RUBYC" --clean-tmpdir -o "$BUILD_DEST/licensed" "$BASE_DIR/exe/licensed"
+
+chmod +x $BUILD_DEST/licensed
+tar -C "$BUILD_DEST" -czf "$PACKAGE_DEST/$TARGET" "./licensed"
+
+echo "licensed built to $PACKAGE_DEST/$TARGET"

data/script/package

@@ -0,0 +1,20 @@
+#!/bin/bash
+#/ Usage: script/package [PLATFORM] [VERSION]
+#/
+#/ Builds distributable packages for licensed.
+#/ Packages are of the form licensed-$VERSION-$PLATFORM-x64.tar.gz and contain a `./licensed` executable
+#/ Built packages are placed in the <root>/pkg directory.
+#/
+#/ OPTIONS:
+#/   [PLATFORM]        (optional, default to all platforms) platform to build exe for
+#/   [VERSION]         (optional, default to current git branch or SHA1) version of licensed to build exe at
+#/
+
+set -e
+
+PLATFORM=""
+if [ -n "$1" ]; then
+  PLATFORM=":$1"
+fi
+
+bundle exec rake "package$PLATFORM"

data/script/packages/linux

@@ -0,0 +1,51 @@
+#!/bin/bash
+#/ Usage: script/packages/linux [VERSION]
+#/
+#/ WARNING: You should not need to call this directly. Please create packages using
+#/ `script/package [platform]` or `bundle exec rake package[platform]`
+#/
+#/ Builds a linux distributable package for licensed for a given and licensed VERSION.
+#/ Packages are of the form licensed-$VERSION-linux-x64.tar.gz and contain a `./licensed` executable
+#/ Built packages are placed in the <root>/pkg directory.
+#/
+#/ If calling from a non-linux OS, docker is used to build a linux binary
+#/
+#/ OPTIONS:
+#/   [VERSION]         (optional, default to current git branch or SHA1) version of licensed to build exe at
+#/
+
+set -euo pipefail
+
+BASE_DIR="$(cd "$(dirname $0)/../.." && pwd)"
+VERSION=${VERSION:=""}
+
+build_linux_docker() {
+  IMAGE="licensed/build-linux"
+  docker build -t "$IMAGE" - < "$BASE_DIR/docker/Dockerfile.build-linux"
+  docker run --rm \
+    -e VERSION="$VERSION" \
+    -v "$BASE_DIR":/var/licensed \
+    -w /var/licensed \
+    "$IMAGE" \
+    "script/build-rubyc-exe"
+}
+
+build_linux_local() {
+  sudo apt-get update && \
+       apt-get install -y --no-install-recommends cmake make gcc pkg-config squashfs-tools curl bison git
+
+  if [ ! -f "$BASE_DIR/bin/rubyc-linux" ]; then
+    mkdir -p "$BASE_DIR/bin"
+    curl -L http://enclose.io/rubyc/rubyc-linux-x64.gz | gunzip > "$BASE_DIR/bin/rubyc-linux"
+    chmod +x "$BASE_DIR/bin/rubyc-linux"
+  fi
+
+  export CPPFLAGS="-P"
+  RUBYC="$BASE_DIR/bin/rubyc-linux" "$BASE_DIR"/script/build-rubyc-exe
+}
+
+if [[ "$(uname -s)" != "Linux" ]]; then
+  build_linux_docker
+else
+  build_linux_local
+fi

data/script/packages/mac

@@ -0,0 +1,35 @@
+#!/bin/bash
+#/ Usage: script/packages/mac [VERSION]
+#/
+#/ WARNING: You should not need to call this directly. Please create packages using
+#/ `script/package [platform]` or `bundle exec rake package[platform]`
+#/
+#/ Builds a mac distributable package for licensed for a given licensed VERSION.
+#/ Packages are of the form licensed-$VERSION-darwin-x64.tar.gz and contain a `./licensed` executable
+#/ Built packages are placed in the <root>/pkg directory.
+#/
+#/ Must be called from a Mac OS.
+#/
+#/ OPTIONS:
+#/   [VERSION]         (optional, default to current git branch or SHA1) version of licensed to build exe at
+#/
+
+set -euo pipefail
+
+if [[ "$(uname -s)" != "Darwin" ]]; then
+  echo "A Mac OS is required to build a licensed executable for mac" >&2
+  exit 1
+fi
+
+BASE_DIR="$(cd "$(dirname $0)/../.." && pwd)"
+
+brew update
+brew list "squashfs" &>/dev/null || brew install "squashfs"
+
+if [ ! -f "$BASE_DIR/bin/rubyc-darwin" ]; then
+  mkdir -p "$BASE_DIR/bin"
+  curl -L http://enclose.io/rubyc/rubyc-darwin-x64.gz | gunzip > "$BASE_DIR/bin/rubyc-darwin"
+  chmod +x "$BASE_DIR/bin/rubyc-darwin"
+fi
+
+RUBYC="$BASE_DIR/bin/rubyc-darwin" "$BASE_DIR"/script/build-rubyc-exe

data/script/source-setup/bundler

@@ -17,4 +17,4 @@ if [ "$1" == "-f" ]; then
   find . -not -regex "\.*" -and -not -name "Gemfile" -print0 | xargs -0 rm -rf
 fi
 
-bundle install --path vendor/gems
+bundle install --path vendor/gems --without ignore

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: licensed
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - GitHub
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-04 00:00:00.000000000 Z
+date: 2018-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: licensee
@@ -87,7 +87,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.10'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -182,16 +182,16 @@ dependencies:
   name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 10.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 10.0.0
 description: Licensed automates extracting and validating the licenses of dependencies.
 email:
 - opensource+licensed@github.com
@@ -211,7 +211,9 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- docker/Dockerfile.build-linux
 - docs/configuration.md
+- docs/packaging.md
 - docs/sources/bower.md
 - docs/sources/bundler.md
 - docs/sources/cabal.md
@@ -244,8 +246,12 @@ files:
 - lib/licensed/version.rb
 - licensed.gemspec
 - script/bootstrap
+- script/build-rubyc-exe
 - script/cibuild
 - script/console
+- script/package
+- script/packages/linux
+- script/packages/mac
 - script/setup
 - script/source-setup/bower
 - script/source-setup/bundler
@@ -266,7 +272,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="