getversion 0.0.4 → 0.0.5

data/lib/getversion/executable.rb

@@ -1,6 +1,5 @@
+require_relative 'executable_path_finder'
 require_relative 'execution_context'
-require_relative 'path_finder'
-require_relative 'path'
 
 module GetVersion
   class Executable
@@ -13,20 +12,20 @@ module GetVersion
       @block = block
     end
 
-    def version
-      c = ExecutionContext.new path
-      c.execute &@block if @block
-    end
-
-    def path
-      dir = PathFinder.find_path @name
-      dir = nil if dir == '.'
-      dir ? Path.new(dir, name).evaluated_path : @name
+    def version(dir=nil)
+      ExecutionContext.execute path(dir), &@block
     end
 
     def self.version(name, &block)
       Executable.new(name, nil, &block).version
     end
 
+    def path(dir=nil)
+      dir ||= ExecutablePathFinder.find_dir @name
+      dir = nil if dir == '.'
+      return @name unless dir
+      File.join dir, @name
+    end
+
   end
 end

data/lib/getversion/executable_path_finder.rb

@@ -0,0 +1,43 @@
+module GetVersion
+  class ExecutablePathFinder
+
+    def initialize(name)
+      @name = name
+    end
+
+    def find_dir
+      path = find_path
+      File.dirname path if path
+    end
+    
+    def find_path
+      is_windows? ? find_path_on_windows : find_path_on_unix
+    end
+
+    def self.find_dir(name)
+      ExecutablePathFinder.new(name).find_dir
+    end
+
+    private
+
+    def is_windows?
+      !ENV['WINDIR'].nil?
+    end
+
+    def find_path_on_unix
+      path = `which #{@name}`.strip
+      return if path.empty?
+      real_path = `readlink #{path}`.strip
+      real_path = nil if real_path.empty?
+      real_path || path
+    end
+
+    def find_path_on_windows
+      paths = ENV['PATH'].split ';'
+      extensions = ENV['PATHEXT'].split ';'
+      possibilities = paths.map { |path| extensions.map { |ext| File.join(path, @name + ext.downcase).gsub('/', '\\') } }.flatten
+      possibilities.find { |f| File.exist? f }
+    end
+
+  end
+end

data/lib/getversion/executable_store.rb

@@ -7,36 +7,16 @@ module GetVersion
       @executables = []
     end
 
-    def get_version(name)
-      executable = find_executable(name) || null_executable(name)
-      executable.version
-    end
-
-    def guess_version(name)
-      executable = find_executable(name) || executable_for_guessing(name)
-      executable.version
-    end
-
     def add_executable(name, namespace, &block)
       @executables << Executable.new(name, namespace, &block)
     end
 
-    private
-
-    def find_executable(name)
+    def get_executable(name)
       @executables.find { |e| e.name == name }
     end
 
-    def null_executable(name)
-      Executable.new name, nil
-    end
+    def get_version(path)
 
-    def executable_for_guessing(name)
-      Executable.new name, nil do
-        args = %w(--version -version /version version --help -help /help help) << nil
-        versions = args.map { |arg| find_version_in_output arg }.compact.uniq
-        versions[0] if versions.length == 1
-      end
     end
 
   end

data/lib/getversion/execution_context.rb

@@ -1,10 +1,10 @@
-require 'yaml'
-require_relative 'executable'
-require_relative 'version'
+require_relative 'platform_versions'
 
 module GetVersion
   class ExecutionContext
 
+    include PlatformVersions
+
     def initialize(path)
       @path = path
     end
@@ -13,24 +13,12 @@ module GetVersion
       instance_eval &block
     end
 
-    def find_version_in_output(arg=nil)
-      output = `"#{@path}" #{arg} 2>&1`
-      v = Version.match output
-      v ? v.version : nil
-    end
-
-    def google_appengine_version
-      path = File.dirname @path
-      version_file = File.join path, 'VERSION'
-      YAML::load_file(version_file)['release']
+    def self.execute(path, &block)
+      ExecutionContext.new(path).execute(&block)
     end
 
-    def osx_version
-      Executable.version('sw_vers') { find_version_in_output '-productVersion' }
-    end
-
-    def windows_version
-      Executable.version('ver') { find_version_in_output }
+    def find_version_in_output(arg=nil)
+      `"#{@path}" #{arg} 2>&1`[/(\d+\.)+\d+/]
     end
 
   end

data/lib/getversion/platform_versions.rb

@@ -0,0 +1,22 @@
+require 'yaml'
+require_relative 'executable'
+
+module GetVersion
+  module PlatformVersions
+
+    def google_appengine_version
+      dir = File.dirname @path
+      version_file = File.join dir, 'VERSION'
+      YAML::load_file(version_file)['release']
+    end
+
+    def osx_version
+      Executable.version('sw_vers') { find_version_in_output '-productVersion' }
+    end
+
+    def windows_version
+      Executable.version('ver') { find_version_in_output }
+    end
+
+  end
+end

data/lib/getversion/version_finder.rb

@@ -0,0 +1,53 @@
+require_relative 'executable'
+
+module GetVersion
+  class VersionFinder
+
+    def initialize(executable_path, executable_store)
+      @path = executable_path
+      @executable_store = executable_store
+    end
+
+    def get_version
+      get null_executable
+    end
+
+    def guess_version
+      get executable_for_guessing
+    end
+
+    private
+
+    def get(executable_if_nil)
+      executable = @executable_store.get_executable(name) || executable_if_nil
+      executable.version dir
+    end
+
+    def path
+      @path
+    end
+
+    def name
+      File.basename path
+    end
+
+    def dir
+      dir = File.dirname path
+      dir = nil if dir == '.'
+      dir
+    end
+
+    def null_executable
+      Executable.new name, nil
+    end
+
+    def executable_for_guessing
+      Executable.new name, nil do
+        args = %w(--version -version /version version --help -help /help help) << nil
+        versions = args.map { |arg| find_version_in_output arg }.compact.uniq
+        versions[0] if versions.length == 1
+      end
+    end
+
+  end
+end

data/lib/getversion.rb

@@ -1,19 +1,24 @@
 require_relative 'getversion/executable_store'
+require_relative 'getversion/version_finder'
 
 module GetVersion
 
   @executable_store = ExecutableStore.new
 
-  def self.[](name)
-    @executable_store.get_version name
+  def self.[](path)
+    version_finder(path).get_version
   end
 
-  def self.guess(name)
-    @executable_store.guess_version name
+  def self.guess(path)
+    version_finder(path).guess_version
   end
 
   private
 
+  def self.version_finder(path)
+    VersionFinder.new(path, @executable_store)
+  end
+
   def self.namespace(namespace)
     @namespace = namespace
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: getversion
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-21 00:00:00.000000000 Z
+date: 2013-07-22 00:00:00.000000000 Z
 dependencies: []
 description: Provides a standard interface for obtaining CLI application version numbers.
 email: matthew@matthewriley.name
@@ -26,13 +26,11 @@ files:
 - lib/getversion/detectors/uncategorised.rb
 - lib/getversion/detectors.rb
 - lib/getversion/executable.rb
+- lib/getversion/executable_path_finder.rb
 - lib/getversion/executable_store.rb
 - lib/getversion/execution_context.rb
-- lib/getversion/path.rb
-- lib/getversion/path_finder.rb
-- lib/getversion/path_finders/unix_path_finder.rb
-- lib/getversion/path_finders/windows_path_finder.rb
-- lib/getversion/version.rb
+- lib/getversion/platform_versions.rb
+- lib/getversion/version_finder.rb
 - lib/getversion.rb
 - !binary |-
   YmluL2dldHZlcnNpb24ucmI=

data/lib/getversion/path.rb

@@ -1,28 +0,0 @@
-class Path
-
-  def initialize(*path)
-    path.select! { |p| p unless p.empty? }
-    @path = File.join path
-  end
-
-  def evaluated_path
-    return unless @path
-    `echo #{normalised_path}`.strip
-  end
-
-  def normalised_path
-    return unless @path
-    is_windows ? @path.gsub('/', '\\') : @path.gsub('\\', '/')
-  end
-
-  def to_s
-    evaluated_path
-  end
-
-  private
-
-  def is_windows
-    !ENV['WINDIR'].nil?
-  end
-
-end

data/lib/getversion/path_finder.rb

@@ -1,17 +0,0 @@
-require_relative 'path_finders/unix_path_finder'
-require_relative 'path_finders/windows_path_finder'
-
-class PathFinder
-
-  def self.find_path(executable_name)
-    path_finder = is_windows? ? WindowsPathFinder.new : UnixPathFinder.new
-    path_finder.find_path executable_name
-  end
-
-  private
-
-  def self.is_windows?
-    !ENV['WINDIR'].nil?
-  end
-
-end

data/lib/getversion/path_finders/unix_path_finder.rb

@@ -1,10 +0,0 @@
-class UnixPathFinder
-
-  def find_path(executable_name)
-    path = `which #{executable_name}`
-    real_path = `readlink #{path}`.strip
-    result = real_path.empty? ? path : real_path
-    result.empty? ? nil : File.dirname(result)
-  end
-
-end

data/lib/getversion/path_finders/windows_path_finder.rb

@@ -1,11 +0,0 @@
-class WindowsPathFinder
-
-  def find_path(executable_name)
-    paths = ENV['PATH'].split ';'
-    extensions = ENV['PATHEXT'].split ';'
-    possibilities = paths.map { |path| extensions.map { |ext| File.join(path, executable_name + ext.downcase).gsub('/', '\\') } }.flatten
-    executable = possibilities.select { |exe| File.exist? exe }.first
-    executable ? File.dirname(executable) : nil
-  end
-
-end

data/lib/getversion/version.rb

@@ -1,43 +0,0 @@
-class Version
-
-  VERSION_REGEX = '(?:\d+\.)+(?:\d+)'
-  DELIMITER = '.'
-
-  attr_accessor :version
-
-  def initialize(version)
-    raise "#{version} is not a valid version." unless Version.is_valid? version
-    @version = version
-  end
-
-  def compact
-    first 2, ''
-  end
-
-  def first(count, delimiter=DELIMITER)
-    to_a.first(count).join(delimiter)
-  end
-
-  def to_s
-    @version
-  end
-
-  def to_a
-    @version.split DELIMITER
-  end
-
-  def self.match(value)
-    exp = Regexp.new VERSION_REGEX
-    version = value.scan(exp)[0]
-    return unless version
-    Version.new(version)
-  end
-
-  private
-
-  def self.is_valid?(version)
-    exp = Regexp.new "^#{VERSION_REGEX}$"
-    version.scan(exp)[0] != nil
-  end
-
-end