expert 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 916ed2662d22a6ac4391d57c19c84e80ae5c154a
+  data.tar.gz: 5680a35349f5c0db60a3538cf9530938bf5b8081
+SHA512:
+  metadata.gz: 9b09c9a30d8f558beed1e3c11a9e82b2255a7b96ab2f174d035500a0098a490d51f8219bf459a8e4e93722ee9692b05203319e901c6a5ba1949882fcb617f425
+  data.tar.gz: cf799ff38ae14b103f6a04fc556b53900303e25e690d3ac1376919936155913e2513fe26acec3fd79dc0d1eb4e1e285c0283ebeddc49052500a9be295da8be8d

data/Gemfile

@@ -0,0 +1,15 @@
+source "https://rubygems.org"
+
+gemspec
+
+ruby '2.0.0', engine: 'jruby', engine_version: JRUBY_VERSION
+
+group :development, :test do
+  gem 'pry-nav'
+  gem 'rake'
+end
+
+group :test do
+  gem 'simplecov'
+  gem 'rspec'
+end

data/History.txt

@@ -0,0 +1,3 @@
+== 1.0.0
+
+* Birthday!

data/Rakefile

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require './lib/expert'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/bin/expert

@@ -0,0 +1,4 @@
+#! /usr/bin/env ruby
+
+require 'expert'
+Expert::Cli.start(ARGV)

data/expert.gemspec

@@ -0,0 +1,19 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'expert/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'expert'
+  s.version  = ::Expert::VERSION
+  s.authors  = ['Cameron Dutro']
+  s.email    = ['camertron@gmail.com']
+  s.homepage = 'http://github.com/camertron'
+
+  s.description = s.summary = 'Manage and install jar dependencies (an alternative to jbundler).'
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+
+  s.require_path = 'lib'
+  s.executables << 'expert'
+  s.files = Dir['{lib,spec,vendor}/**/*', 'Gemfile', 'History.txt', 'README.md', 'Rakefile', 'expert.gemspec']
+end

data/lib/expert.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+
+module Expert
+  autoload :ClasspathFile,    'expert/classpath_file'
+  autoload :Cli,              'expert/cli'
+  autoload :Environment,      'expert/environment'
+  autoload :Jarfile,          'expert/jarfile'
+  autoload :JarDependency,    'expert/jar_dependency'
+  autoload :JarfileParser,    'expert/jarfile_parser'
+  autoload :JarfileTokenizer, 'expert/jarfile_tokenizer'
+  autoload :Maven,            'expert/maven'
+  autoload :PomFile,          'expert/pom_file'
+
+  # The Jarfile declares dependencies. The pom/classpath function like a
+  # Gemfile.lock or Jarfile.lock.
+  DEFAULT_JARFILE_PATH = './Jarfile'
+  DEFAULT_POM_PATH = './pom.xml'
+  DEFAULT_CLASSPATH_FILE = './classpath.txt'
+  MAVEN_VERSION = '3.3.3'
+
+  class << self
+    def environment
+      @environment ||= begin
+        check_bundler_required
+        check_jarfile_exists
+
+        Environment.new(load_jarfile, load_pom, load_classpath)
+      end
+    end
+
+    def jarfile_path
+      ENV.fetch('EXPERT_JARFILE', DEFAULT_JARFILE_PATH)
+    end
+
+    def pom_path
+      ENV.fetch('EXPERT_POM', DEFAULT_POM_PATH)
+    end
+
+    def classpath_file_path
+      ENV.fetch('EXPERT_CLASSPATH_FILE', DEFAULT_CLASSPATH_FILE)
+    end
+
+    protected
+
+    def check_bundler_required
+      unless defined?(Bundler)
+        raise "Bundler hasn't been required. Please run expert in the context "\
+          "of your bundle."
+      end
+    end
+
+    def check_jarfile_exists
+      unless File.exist?(jarfile_path)
+        raise "Couldn't find a Jarfile at #{jarfile_path}. A Jarfile is "\
+          "required to declare jar dependencies. You can manually specify a "\
+          "Jarfile location via the EXPERT_JARFILE environment variable."
+      end
+    end
+
+    def load_jarfile
+      Jarfile.from_path(jarfile_path)
+    end
+
+    def load_pom
+      if File.exist?(pom_path)
+        PomFile.from_path(pom_path)
+      end
+    end
+
+    def load_classpath
+      if File.exist?(classpath_file_path)
+        ClasspathFile.from_path(classpath_file_path)
+      end
+    end
+  end
+end

data/lib/expert/classpath_file.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+module Expert
+  class ClasspathFile
+    attr_reader :paths
+
+    class << self
+      def from_path(path)
+        new(load(path))
+      end
+
+      protected
+
+      def load(path)
+        File.read(path).split(':')
+      end
+    end
+
+    def initialize(paths)
+      @paths = paths
+    end
+
+    def require_all
+      paths.each { |p| Kernel.require(p) }
+    end
+  end
+end

data/lib/expert/cli.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+module Expert
+  class Cli
+    class << self
+      def start(argv)
+        cmd = argv[0].to_sym
+
+        if respond_to?(cmd)
+          public_send(cmd, argv[1..-1])
+        else
+          raise "Couldn't find command '#{cmd}'"
+        end
+      end
+
+      def install(args)
+        Expert.environment.install
+      end
+    end
+  end
+end

data/lib/expert/environment.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+module Expert
+  class DependenciesNotInstalledError < StandardError; end
+
+  class Environment
+    attr_reader :jarfile, :pom, :classpath
+
+    def initialize(jarfile, pom, classpath)
+      @jarfile = jarfile
+      @pom = pom
+      @classpath = classpath
+    end
+
+    def install
+      install_pom
+      install_classpath
+    end
+
+    def installed?
+      pom && classpath
+    end
+
+    def require_all
+      if installed?
+        classpath.require_all
+      else
+        raise DependenciesNotInstalledError,
+          "Maven dependencies haven't been installed yet (did you forget to "\
+          "run `expert install`?)"
+      end
+    end
+
+    protected
+
+    def install_pom
+      @pom = PomFile.new(jarfile.dependencies)
+      pom.write(Expert.pom_path)
+    end
+
+    def install_classpath
+      mvn.resolve
+      mvn.build_classpath(Expert.classpath_file_path)
+      @classpath = ClasspathFile.from_path(Expert.classpath_file_path)
+    end
+
+    def mvn
+      Expert::Maven
+    end
+  end
+end

data/lib/expert/jar_dependency.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module Expert
+  class JarDependency
+    attr_reader :group_id, :artifact_id, :version
+
+    def initialize(group_id, artifact_id, version)
+      @group_id = group_id
+      @artifact_id = artifact_id
+      @version = version
+    end
+
+    def classifier
+      "#{group_id}:#{artifact_id}"
+    end
+  end
+end

data/lib/expert/jarfile.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+module Expert
+  class Jarfile
+    attr_reader :dependencies
+
+    class << self
+      def from_path(jarfile_path)
+        new(load(jarfile_path))
+      end
+
+      protected
+
+      def load(jarfile_path)
+        jar_deps = parse(jar_requirements_from_gems.join("\n"))
+        jarfile_deps = parse(File.read(jarfile_path))
+        (jar_deps + jarfile_deps).uniq(&:classifier)
+      end
+
+      def parse(contents)
+        tokens = JarfileTokenizer.tokenize(contents)
+        JarfileParser.new(tokens).dependencies
+      end
+
+      def jar_requirements_from_gems
+        requirements_from_gems.select do |requirement|
+          requirement.respond_to?(:start_with?) && requirement.start_with?('jar ')
+        end
+      end
+
+      def requirements_from_gems
+        Bundler.environment.specs.flat_map(&:requirements)
+      end
+    end
+
+    def initialize(dependencies)
+      @dependencies = dependencies
+    end
+  end
+end

data/lib/expert/jarfile_parser.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+module Expert
+  class UnexpectedTokenError < StandardError; end
+
+  class JarfileParser
+    attr_reader :tokens, :index
+
+    def initialize(tokens)
+      @tokens = tokens
+    end
+
+    def each_dependency(&block)
+      rewind
+      each_jar(&block)
+    end
+
+    def dependencies
+      rewind
+      each_jar.to_a
+    end
+
+    protected
+
+    def each_jar
+      if block_given?
+        consume
+        yield jar until eos?
+      else
+        to_enum(__method__)
+      end
+    end
+
+    def jar
+      consume(:jar)
+      consume(:quote)
+      group_id, artifact_id = consume(:string).value.split(':')
+      consume(:quote)
+      consume(:comma)
+      consume(:quote)
+      version = consume(:string).value
+      consume(:quote)
+      JarDependency.new(group_id, artifact_id, version)
+    end
+
+    def consume(type = nil)
+      token = current_token
+
+      if type
+        if current_token.type == type && !eos?
+          @index += 1
+        else
+          raise UnexpectedTokenError,
+            "Expected token of type '#{type}', got '#{current_token.type}'"
+        end
+      end
+
+      while should_skip_current?
+        @index += 1
+      end
+
+      token
+    end
+
+    def should_skip_current?
+      !eos? && current_token.type == :comment
+    end
+
+    def current_token
+      tokens[index]
+    end
+
+    def eos?
+      index >= tokens.size
+    end
+
+    def rewind
+      @index = 0
+    end
+  end
+end

data/lib/expert/jarfile_tokenizer.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+module Expert
+  Token = Struct.new(:type, :value)
+
+  # jar 'org.eclipse.jgit:org.eclipse.jgit', '3.4.1.201406201815-r'
+  class JarfileTokenizer
+    TOKEN_TYPE_REGEXES = {
+      jar: /jar/,
+      quote: /['"]/,
+      comma: /,/,
+      comment: /#.*\z/m
+    }
+
+    TOKEN_TYPES = TOKEN_TYPE_REGEXES.keys
+    DEFAULT_TOKEN_TYPE = :string
+
+    SPLITTER = Regexp.new(
+      "(#{TOKEN_TYPE_REGEXES.values.map(&:source).join('|')})"
+    )
+
+    class << self
+      def tokenize(content)
+        raw_tokens = content.split(SPLITTER)
+        identify(raw_tokens.reject { |t| t.strip.empty? })
+      end
+
+      protected
+
+      def identify(raw_tokens)
+        raw_tokens.map do |token|
+          type = TOKEN_TYPES.find do |type|
+            token =~ TOKEN_TYPE_REGEXES[type]
+          end
+
+          Token.new(type || DEFAULT_TOKEN_TYPE, token)
+        end
+      end
+    end
+  end
+end

data/lib/expert/maven.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+module Expert
+  class Maven
+
+    class << self
+      def execute(cmd)
+        system("#{mvn_path} #{cmd}")
+      end
+
+      def resolve
+        execute('dependency:resolve')
+      end
+
+      def build_classpath(output_file)
+        execute("dependency:build-classpath -Dmdep.outputFile=#{output_file}")
+      end
+
+      def mvn_path
+        @mvn_path ||= File.expand_path(
+          "../../../vendor/apache-maven-#{Expert::MAVEN_VERSION}/bin/mvn",
+          __FILE__
+        )
+      end
+    end
+
+  end
+end