visual_studio 0.0.0.3 → 0.0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88a2fe77633635e22f183f01318391c8eb6e3b31
-  data.tar.gz: 7ce47ef7267cf01219c084ab82ff50546b5fb0d2
+  metadata.gz: 170f4bf5dfff415c14da637f32121dca1ae2774e
+  data.tar.gz: 0b57db076db928c11688e9cbcc382c1fdbf6abbc
 SHA512:
-  metadata.gz: 4088e2022f8dbe67837699751270d313a1f04fcd804207c2fbd411c3b23b39cd64652fc258159dcd6572518405fd9f77dde98452279338110ba2c3bdf4b92990
-  data.tar.gz: 87c96da074a44c72c511e4a280bd9228e75fbc7cd9202018134e136517b300933fa2fd5f2f8f6ea1c74d679e2a7a2e5e8cc014d00ee6c60d177e187c7cd25e22
+  metadata.gz: 8a656e2a6472ec03ff48536a522b8f6bf0441004ba6d05e390d44ec3b5de56870d2d0cf5d3e263f1ea9b3de60cac6ecca141af8280c60ca91d868b49627d4057
+  data.tar.gz: 521e8988157ef6c3165cbfc35a533d3a77186fc04ea553eda259af0cedf4f48dfe9d333acb4c6cfd38734be964c17244ad888c848ee0b050d93055806f2140b7

data/README.md

@@ -9,11 +9,69 @@ This will (hopefully) become the de-facto gem for inspecting Visual Studio insta
 
 Documentation is on the back-burner, so for now:
 
-```ruby
-VisualStudio.available? # true
-vs = VisualStudio.find :vs2015
-vs.name.pretty # "Visual Studio 2015"
-vs.name # "vs2015"
-vs.version # "14.0"
-vs.install # "C:/Program Files (x86)/Microsoft Visual Studio 14.0/"
+```Ruby
+
+VisualStudio.available?
+VisualStudio.installed?
+ => true
+
+VisualStudio.available? 'vs2015'
+VisualStudio.installed? 'vs2015'
+ => true
+
+VisualStudio.latest
+VisualStudio.install
+ => #<VisualStudio::Install @name=#<VisualStudio::Helpers::Name "vs2015" @pretty=""Visual Studio 2015"> ...>
+
+VisualStudio.install 'vs2015'
+VisualStudio.find 'vs2015'
+VisualStudio.find_by(name: 'vs2015')
+VisualStudio.find_by_name 'vs2015'
+VisualStudio.find_by(version: 'vs2015')
+VisualStudio.find_by_version '14.0'
+ => #<VisualStudio::Install @name=#<VisualStudio::Helpers::Name "vs2015" @pretty="Visual Studio 2015"> ...>
+
+vs = VisualStudio.latest
+vs.name
+ => "vs2015"
+vs.name.pretty
+ => "vs2015"
+vs.version
+ => "14.0"
+vs.root
+ => "C:/Program Files (x86)/Microsoft Visual Studio 14.0"
+vs.suite[:c_and_cpp]
+vs.products[:c_and_cpp]
+ => #<VisualStudio::Product @name=#<VisualStudio::Helpers::Name "VC" @pretty="Microsoft Visual C/C++"> ...>
+vs.suite[:csharp]
+vs.products[:csharp]
+ => #<VisualStudio::Product @name=#<VisualStudio::Helpers::Name "VC" @pretty="Microsoft Visual C#"> ...>
+
+vc = vs.products[:c_and_cpp]
+vc.name
+ => "VC"
+vc.name.pretty
+ => "Microsoft Visual C/C++"
+vc.version
+ => "14.0"
+vc.root
+ => "C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC"
+vc.paths.includes
+ => {:x86 => ..., :x86_64 => ...}
+vc.paths.libraries
+ => {:x86 => ..., :x86_64 => ...}
+vc.sdks
+ => {:windows => ...}
+vc.platforms
+ => [:windows]
+vc.architectures
+ => [:x86, :x86_64]
+vc.supports? :windows
+ => true
+vc.supports? :arm
+ => false
+env = vc.environment target: {platform: :windows,
+                                  arch: :x86_64},
+                     base: ENV
+=> {"PATH" => "...", ...}
 ```

data/lib/visual_studio/gem.rb

@@ -0,0 +1,58 @@
+require 'ostruct'
+
+module VisualStudio
+  module Gem
+    # The name of this Gem.
+    def self.name
+      "visual_studio"
+    end
+
+    # The name and email address of the primary author.
+    def self.author
+      self.authors.first
+    end
+
+    # The name and email addresses of all authors.
+    def self.authors
+      [["Michael Williams", "m.t.williams@live.com"]].map do |author|
+        name, email = author
+        OpenStruct.new(name: name, email: email)
+      end
+    end
+
+    # This Gem's homepage URL.
+    def self.homepage
+      "https://github.com/mtwilliams/visual_studio"
+    end
+
+    # This Gem's URL.
+    def self.url
+      "https://rubygems.org/gems/#{self.name}"
+    end
+
+    # A short summary of this Gem.
+    def self.summary
+      "Inspect Visual Studio installs and generate Visual Studio project files."
+    end
+
+    # A full description of this Gem.
+    def self.description
+      "This will (hopefully) become the de-facto gem for inspecting Visual Studio installs and generating Visual Studio project files."
+    end
+
+    module VERSION #:nodoc:
+      MAJOR, MINOR, PATCH, PRE = [0, 0, 0, 4]
+      STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+    end
+
+    # The semantic version of the this Gem.
+    def self.version
+      Gem::VERSION::STRING
+    end
+
+    # The license covering this Gem.
+    def self.license
+      "Public Domain"
+    end
+  end
+end

data/lib/visual_studio/helpers/pretty_string.rb

@@ -0,0 +1,11 @@
+module VisualStudio
+  module Helpers
+    class PrettyString < String
+      attr_reader :pretty
+      def initialize(name, opts={})
+        super(name)
+        @pretty = opts[:pretty] if opts.include? :pretty
+      end
+    end
+  end
+end

data/lib/visual_studio/install.rb

@@ -1,69 +1,84 @@
 module VisualStudio
   class Install
-    attr_reader :name
-    attr_reader :version
-    attr_reader :root
-    attr_reader :toolsets
-    attr_reader :sdks
+    attr_reader :name,
+                :version,
+                :root,
+                :products
 
-    def initialize(opts={})
-      @name = opts[:name]
-      @version = opts[:version]
-      @root = opts[:root]
-      @toolsets = opts[:toolsets]
-      @sdks = opts[:sdks]
+    def initialize(desc={})
+      @name      = desc[:name]
+      @version   = desc[:version]
+      @root      = desc[:root]
+      @products  = desc[:products]
     end
 
-    def self.exists?(name_or_version)
-      !!(find(name_or_version))
+    def self.available?(name_or_version)
+      !!(self.find(name_or_version))
+    end
+
+    def self.latest
+      VisualStudio::VERSIONS.map{|version| self.find_by_version(version)}.compact.first
     end
 
     def self.find(name_or_version)
-      return find_by_name(name_or_version) if NAMES.include?(name_or_version)
-      return find_by_version(name_or_version) if VERSIONS.include?(name_or_version)
+      if VisualStudio::NAMES.include?(name_or_version)
+        self.find_by_name(name_or_version)
+      elsif VisualStudio::VERSIONS.include?(name_or_version)
+        self.find_by_version(name_or_version)
+      else
+        # TODO(mtwilliams): Raise an exception.
+        # raise VisualStudio::InvalidCriteria.new("Expected a name or version")
+      end
+    end
+
+    def self.find_by(criteria)
+      if criteria.include?(:name)
+        self.find_by_name(criteria[:name])
+      elsif criteria.include?(:version)
+        self.find_by_version(criteria[:version])
+      else
+        # TODO(mtwilliams): Raise an exception.
+        # raise VisualStudio::InvalidCriteria.new("Expected 'name' or 'version' to be specified")
+      end
     end
 
     def self.find_by_name(name)
-      find_by_version(NAME_TO_VERSION[name]) if NAMES.include?(name)
+      if VisualStudio::NAMES.include?(name)
+        self.find_by_version(VisualStudio::NAME_TO_VERSION[name])
+      else
+        # TODO(mtwilliams): Raise an exception.
+        # raise VisualStudio::InvalidName.new(...)
+      end
     end
 
     def self.find_by_version(version)
-      install = _find_install_via_registry(version)
-      return if install.nil?
+      if VisualStudio::VERSIONS.include?(version)
+        # Try to find any products (that we care about) for this version.
+        c_and_cpp = VisualStudio::Product.find('VC', version)
+        csharp    = VisualStudio::Product.find('VC#', version)
 
-      # HACK(mtwilliams): Assume C/C++ is installed.
-      c_and_cpp = File.join(install, 'VC')
-      # TODO(mtwilliams): Search for other toolsets, notably C#.
-      csharp = nil # File.join(install, 'VC#')
+        # If no products (that we care about) for this version are installed,
+        # then for all intents and purposes this version of Visual Studio
+        # is "not installed". This might not be the truth, but who gives a fuck
+        # about Visual Basic anymore?!
+        return nil if [c_and_cpp, csharp].all?{|product| product.nil?}
 
-      # TODO(mtwilliams): Look for SDKs, including packaged ones.
-      sdk = nil # ...
+        name = Helpers::PrettyString.new VisualStudio::VERSION_TO_NAME[version],
+                                         pretty: VisualStudio::VERSION_TO_PRETTY_NAME[version]
 
-      # TODO(mtwilliams): Cache.
-      VisualStudio::Install.new(name: VERSION_TO_NAME[version],
-                                version: version,
-                                root: install,
-                                toolsets: Hashie::Mash.new({
-                                  c: c_and_cpp,
-                                  cpp: c_and_cpp,
-                                  csharp: csharp }),
-                                sdks: Hashie::Mash.new({
-                                  windows: nil }))
-    end
+        root = File.expand_path(File.join([c_and_cpp, csharp].compact.first.root, '..'))
 
-    private
-      def self._find_install_via_registry(version)
-        # TODO(mtwilliams): Try other products, like C#.
-        keys = ["SOFTWARE\\Microsoft\\VisualStudio\\#{version}\\Setup\\VC",
-                "SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\#{version}\\Setup\\VC"]
-        keys.each do |key|
-          begin
-            require 'win32/registry'
-            return File.expand_path(File.join(::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, ::Win32::Registry::KEY_READ)['ProductDir'], '..')).to_s
-          rescue
-            return nil
-          end
-        end
+        products = {c_and_cpp: c_and_cpp, csharp: csharp}
+        products = products.reject{|_, v| v.nil?}
+
+        VisualStudio::Install.new(name: name,
+                                  version: version,
+                                  root: root,
+                                  products: products)
+      else
+        # TODO(mtwilliams): Raise an exception.
+        # raise VisualStudio::InvalidVersion.new(...)
       end
+    end
   end
 end

data/lib/visual_studio/product.rb

@@ -0,0 +1,122 @@
+module VisualStudio
+  class Product
+    NAMES               = ['VC', 'VC#']
+    PRETTY_NAMES        = ['Visual C/C++', 'Visual C#']
+    NAME_TO_PRETTY_NAME = Hash[NAMES.zip(PRETTY_NAMES)]
+
+    attr_reader :name,
+                :version,
+                :root,
+                :includes,
+                :libraries,
+                :binaries,
+                :sdks,
+                :supports
+
+    def initialize(desc)
+      @name      = desc[:name]
+      @version   = desc[:version]
+      @root      = desc[:root]
+      @includes  = desc[:includes]
+      @libraries = desc[:libraries]
+      @binaries  = desc[:binaries]
+      @sdks      = desc[:sdks]
+      @supports  = desc[:supports]
+    end
+
+    def self.find(product, version)
+      if VisualStudio::Product::NAMES.include?(product)
+        name = Helpers::PrettyString.new VisualStudio::VERSION_TO_NAME[version],
+                                         pretty: VisualStudio::VERSION_TO_PRETTY_NAME[version]
+
+        root = self._find_via_registry(product, version)
+        return nil if root.nil?
+
+        includes, libraries, binaries =
+          case product
+            when 'VC'
+              case version.to_f
+                when 8.0..11.0
+                  # TODO(mtwilliams): Check if x86_64 support exists.
+                  includes  = [File.join(root, 'VC', 'include')]
+                  libraries = {:x86    => [File.join(root, 'VC', 'lib')],
+                               :x86_64 => []}
+                  binaries  = {:x86    => [File.join(root, 'VC', 'bin')],
+                               :x86_64 => []}
+                  [includes, libraries, binaries]
+                when 12.0..14.0
+                  # TODO(mtwilliams): Select the 64-bit and ARM host variants
+                  # when applicable, i.e. when running on 64-bit or ARM.
+                  includes  = [File.join(root, 'VC', 'include')]
+                  libraries = {:x86    => [File.join(root, 'VC', 'lib')],
+                               :x86_64 => [File.join(root, 'VC', 'lib', 'amd64')],
+                               :arm    => [File.join(root, 'VC', 'lib', 'arm')]}
+                  binaries  = {:x86    => [File.join(root, 'VC', 'bin')],
+                               :x86_64 => [File.join(root, 'VC', 'bin', 'x86_amd64')],
+                               :arm    => [File.join(root, 'VC', 'bin', 'x86_arm')]}
+                  [includes, libraries, binaries]
+                else
+                  # TODO(mtwilliams): Raise a proper extension.
+                  # raise VisualStudio::Unsupported(...)
+                  raise "Wha-?"
+                end
+            when 'VC#'
+              # TODO(mtwilliams): Determine search paths.
+              [[], {}, {}]
+            end
+
+        # TODO(mtwilliams): Handle the Xbox One and PS4.
+        # TODO(mtwilliams): Actually search for the SDKs.
+        sdks = VisualStudio::VERSION_TO_SDKS[version][:windows]
+
+        platforms = [:windows]
+        architectures = case product
+                          when 'VC'
+                            case version.to_f
+                              when 8.0..11.0
+                                # TODO(mtwilliams): Check if x86_64 support exists.
+                                [:x86]
+                              when 12.0..14.0
+                                [:x86, :x86_64, :arm]
+                              end
+                          when 'VC#'
+                            # TODO(mtwilliams): Determine 64-bit support?
+                            [:x86, :x86_64, :arm]
+                          end
+
+        VisualStudio::Product.new(name: name,
+                                  version: version,
+                                  root: root,
+                                  includes: includes,
+                                  libraries: libraries,
+                                  binaries: binaries,
+                                  sdks: ({windows: sdks}),
+                                  supports: ({platforms: platforms,
+                                              architectures: architectures}))
+      else
+        # TODO(mtwilliams): Raise an exception.
+        # raise VisualStudio::InvalidVersion.new(...)
+      end
+    end
+
+    private
+      def self._find_via_registry(product, version)
+        # We try to find a full version of Visual Studio. If we can't, then
+        # we look for standalone verions, i.e. Express Editions. This is only
+        # required for 2005-2010 so this logic can be removed when we drop
+        # support for them.
+        keys = ["SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\#{version}\\Setup\\#{product}",
+                "SOFTWARE\\Microsoft\\VisualStudio\\#{version}\\Setup\\#{product}",
+                "SOFTWARE\\Wow6432Node\\Microsoft\\VCExpress\\#{version}\\Setup\\#{product}",
+                "SOFTWARE\\Microsoft\\VCExpress\\#{version}\\Setup\\#{product}"]
+        installs = keys.map do |key|
+          begin
+            require 'win32/registry'
+            return File.expand_path(::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, ::Win32::Registry::KEY_READ)['ProductDir']).to_s
+          rescue
+          end
+        end
+        installs.compact.first
+      end
+  end
+end

data/lib/visual_studio.rb

@@ -1,43 +1,70 @@
-require 'hashie'
-
 module VisualStudio
-  autoload :VERSION, 'visual_studio/version'
+  NAMES        = ['vs2015', 'vs2013', 'vs2012', 'vs2010', 'vs2008', 'vs2005']
 
-  autoload :Name, 'visual_studio/name'
-  autoload :Install, 'visual_studio/install'
+  PRETTY_NAMES = ['Visual Studio 2015', 'Visual Studio 2013',
+                  'Visual Studio 2012', 'Visual Studio 2010',
+                  'Visual Studio 2008', 'Visual Studio 2005']
 
-  NAMES = [VisualStudio::Name.new('vs2015', pretty: 'Visual Studio 2015'),
-           VisualStudio::Name.new('vs2013', pretty: 'Visual Studio 2013'),
-           VisualStudio::Name.new('vs2012', pretty: 'Visual Studio 2012'),
-           VisualStudio::Name.new('vs2010', pretty: 'Visual Studio 2010'),
-           VisualStudio::Name.new('vs2008', pretty: 'Visual Studio 2008'),
-           VisualStudio::Name.new('vs2005', pretty: 'Visual Studio 2005'),
-           VisualStudio::Name.new('vs2003', pretty: 'Visual Studio .NET 2003'),
-           VisualStudio::Name.new('vs2003', pretty: 'Visual Studio .NET 2002'),
-           VisualStudio::Name.new('vs6', pretty: 'Visual Studio 6.0')]
+  VERSIONS     = [14.0, 12.0, 11.0, 10.0, 9.0, 8.0].map(&:to_s)
 
-  VERSIONS = %w{14.0 12.0 11.0 10.0 9.0 8.0 7.1 7.0 6.0}
+  SDKS         = [{windows:  %w{10.0 8.1 8.0 7.1}},
+                  {windows:       %w{8.1 8.0 7.1}},
+                  {windows:       %w{8.1 8.0 7.1}},
+                  {windows:       %w{8.1 8.0 7.1}},
+                  {windows:               %w{7.1 7.0}},
+                  {windows:               %w{7.1 7.0}}]
 
   NAME_TO_VERSION = Hash[NAMES.zip(VERSIONS)]
   VERSION_TO_NAME = Hash[VERSIONS.zip(NAMES)]
 
-  def self.available?
-    VERSIONS.any? { |version| self.installed?(version) }
+  NAME_TO_PRETTY_NAME = Hash[NAMES.zip(PRETTY_NAMES)]
+  VERSION_TO_PRETTY_NAME = Hash[VERSIONS.zip(PRETTY_NAMES)]
+
+  NAME_TO_SDKS = Hash[NAMES.zip(SDKS)]
+  VERSION_TO_SDKS = Hash[VERSIONS.zip(SDKS)]
+
+  require 'visual_studio/helpers/pretty_string'
+
+  require 'visual_studio/install'
+  require 'visual_studio/product'
+
+  def self.available?(name_or_version=nil)
+    self.installed?(name_or_version)
   end
 
-  def self.installed?(name_or_version)
-    VisualStudio::Install.exists?(name_or_version)
+  def self.installed?(name_or_version=nil)
+    if name_or_version
+      VisualStudio::Install.available?(name_or_version)
+    else
+      VisualStudio::VERSIONS.any?{|version| VisualStudio.installed?(version)}
+    end
+  end
+
+  def self.install(name_or_version=nil)
+    if name_or_version
+      self.find(name_or_version)
+    else
+      self.latest
+    end
+  end
+
+  def self.latest
+    VisualStudio::Install.latest
   end
 
   def self.find(name_or_version)
     VisualStudio::Install.find(name_or_version)
   end
 
+  def self.find_by(criteria)
+    VisualStudio::Install.find_by(criteria)
+  end
+
   def self.find_by_name(name)
     VisualStudio::Install.find_by_name(name)
   end
 
   def self.find_by_version(version)
-    VisualStudio::Install.find_by_version(version)
+    VisualStudio::Install.find_by_version(name)
   end
 end

data/visual_studio.gemspec

@@ -1,26 +1,25 @@
 $:.push File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
-require 'visual_studio/version'
+require 'visual_studio/gem'
 
 Gem::Specification.new do |s|
-  s.name              = 'visual_studio'
-  s.version           = VisualStudio.version
+  # This information has been refactored into `lib/visual_studio/gem.lib`.
+  s.name              = VisualStudio::Gem.name
+  s.version           = VisualStudio::Gem.version
   s.platform          = Gem::Platform::RUBY
-  s.author            = 'Michael Williams'
-  s.email             = 'm.t.williams@live.com'
-  s.homepage          = 'https://github.com/mtwilliams/visual_studio'
-  s.summary           = 'Inspect Visual Studio installs and generate Visual Studio project files.'
-  s.description       = 'This will (hopefully) become the de-facto gem for inspecting Visual Studio installs and generating Visual Studio project files.'
-  s.license           = 'Public Domain'
+  s.author            = VisualStudio::Gem.author.name
+  s.email             = VisualStudio::Gem.author.email
+  s.homepage          = VisualStudio::Gem.homepage
+  s.summary           = VisualStudio::Gem.summary
+  s.description       = VisualStudio::Gem.description
+  s.license           = VisualStudio::Gem.license
 
-  s.required_ruby_version = '>= 1.9.3'
+  s.required_ruby_version = '>= 2.0.0'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = %w(lib)
 
-  s.add_dependency 'hashie'
-
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'cucumber'
   s.add_development_dependency 'aruba'

data/visual_studio.sublime-project

@@ -12,7 +12,8 @@
                         ],
 
                         "folder_exclude_patterns": [
-                                ".bundle"
+                                ".bundle",
+                                "pkg"
                         ]
                 }
         ]

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: visual_studio
 version: !ruby/object:Gem::Version
-  version: 0.0.0.3
+  version: 0.0.0.4
 platform: ruby
 authors:
 - Michael Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-06 00:00:00.000000000 Z
+date: 2015-09-27 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: hashie
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -79,9 +65,10 @@ files:
 - README.md
 - Rakefile
 - lib/visual_studio.rb
+- lib/visual_studio/gem.rb
+- lib/visual_studio/helpers/pretty_string.rb
 - lib/visual_studio/install.rb
-- lib/visual_studio/name.rb
-- lib/visual_studio/version.rb
+- lib/visual_studio/product.rb
 - visual_studio.gemspec
 - visual_studio.sublime-project
 homepage: https://github.com/mtwilliams/visual_studio
@@ -96,7 +83,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/visual_studio/name.rb

@@ -1,9 +0,0 @@
-module VisualStudio
-  class Name < String
-    attr_reader :pretty
-    def initialize(name, opts={})
-      super(name)
-      @pretty = opts[:pretty] if opts[:pretty]
-    end
-  end
-end

data/lib/visual_studio/version.rb

@@ -1,11 +0,0 @@
-class VisualStudio
-  module VERSION #:nodoc:
-    MAJOR, MINOR, PATCH, PRE = [0, 0, 0, 3]
-    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
-  end
-
-  # Returns the semantic version of `visual_studio`.
-  def self.version
-    VisualStudio::VERSION::STRING
-  end
-end