natives 0.4.1 → 0.5.0

data/lib/natives/catalog.rb

@@ -0,0 +1,56 @@
+require 'natives/catalog/loader'
+require 'natives/catalog/selector'
+
+module Natives
+  class Catalog
+
+    CATALOG_PATH_IN_GEM = File.absolute_path(File.join(
+                            File.dirname(__FILE__), '..', '..', 'catalogs'))
+
+    WORKING_DIR_CATALOG_DIRNAME = 'natives-catalogs'
+
+    attr_reader :platform, :platform_version, :package_provider, :name
+
+    def initialize(catalog_name,
+                   platform, platform_version,
+                   package_provider,
+                   opts={})
+
+      @name = catalog_name.to_s
+      @platform = platform.to_s
+      @platform_version = platform_version.to_s
+      @package_provider = package_provider.to_s
+
+      @loader = opts.fetch(:loader, Loader.new)
+      @working_dir = opts.fetch(:working_dir, Dir.pwd)
+
+      reload
+    end
+
+    def reload
+      @catalogs = @loader.load_from_paths(catalog_paths)
+    end
+
+    def to_hash
+      @catalogs.fetch(self.name, {})
+    end
+
+    def native_packages_for(*entry_names)
+      packages = Array(entry_names).flatten.map do |entry_name|
+        Selector.new(self.to_hash.fetch(entry_name, {})).
+          value_for(@platform, @platform_version, @package_provider)
+      end
+      packages.flatten.compact
+    end
+
+    protected
+
+    def catalog_paths
+      [
+        CATALOG_PATH_IN_GEM,
+        File.absolute_path(File.join(@working_dir, WORKING_DIR_CATALOG_DIRNAME))
+      ]
+    end
+
+  end
+end

data/lib/natives/cli.rb

@@ -1,60 +1,45 @@
 require 'thor'
-require 'natives/app'
-require 'natives/gemfile_viewer'
+require 'natives/apps'
 
 module Natives
   class Cli < Thor
-    default_task :install
 
-    desc 'version', 'print the version number'
-    def version
-      puts IO.read('VERSION')
-    end
-
-    desc 'install [ENTRY1 ENTRY2 ..]',
-         'install native packages required by the catalog entries'
-
-    method_option :catalog, default: 'rubygems',
-      aliases: '-c',
+    desc 'list [ENTRY1 ENTRY2 ..]',
+      'list native packages required by the catalog entries'
+    method_option :catalog, default: 'rubygems', aliases: '-c',
       desc: 'use this catalog'
     method_option :gemfile, default: 'Gemfile',
       desc: 'use gems in the gemfile as the catalog entries'
-    method_option :"update-provider", type: 'boolean',
-      default: false,
-      aliases: '-u',
-      desc: "update package provider's repo (eg. apt-get update)"
-
-    method_option :"test-run", type: 'boolean',
-      default: false,
-      aliases: %w(-t --dry-run),
-      desc: "run without actually installing native packages"
-
-    def install(*packages)
-      catalog = options[:catalog]
-      configs = {
-        update_provider: options['update-provider'],
-        test_run: options['test-run']
-      }
-      if catalog == 'rubygems' && packages.empty?
-        packages = packages_in_gemfile(options[:gemfile])
+    def list(*entry_names)
+      app = Apps::List.new
+
+      catalog_name = options[:catalog]
+      if catalog_name == 'rubygems' && entry_names.empty?
+        packages = app.natives_for_gemfile(options[:gemfile])
+      else
+        packages = app.natives_for(catalog_name, entry_names)
       end
 
-      puts "catalog: #{catalog.inspect}"
-      puts "entries: #{packages.inspect}"
-      puts "configs: #{configs}"
-      puts ""
-
-      Natives::App.new.install(catalog, packages, configs)
-
+      puts packages
     rescue => ex
       $stderr.puts ex.message
     end
 
-    protected
-
-    def packages_in_gemfile(gemfile_path)
-      Natives::GemfileViewer.new(gemfile_path).packages
+    desc 'detect',
+      'detect and print platform and package provider information'
+    def detect
+      app = Apps::Detect.new
+      puts app.detection_info
     end
 
+    desc 'version',
+      'print version information'
+    def version
+      version_file = File.expand_path(File.join(
+        File.dirname(__FILE__), '..', '..', 'VERSION'))
+
+      puts IO.read(version_file)
+    end
   end
+
 end

data/lib/natives/gemfile_viewer.rb

@@ -1,29 +1,32 @@
-
 module Natives
   class GemfileViewer
     def initialize(gemfile_path)
       @gemfile_path = gemfile_path
     end
 
-    def packages
-      begin
-        # After several trial-and-error, this works:
-        # 1. cd to the dir containing the gemfile
-        # 2. after that run bundle show
-        gemfile_dir = File.expand_path(File.dirname(@gemfile_path))
-        gemfile_name = File.basename(@gemfile_path)
-        output = %x{cd '#{gemfile_dir}' && BUNDLE_GEMFILE=#{gemfile_name} bundle show 2>&1}
-        success = ($?.exitstatus == 0)
-        unless success
-          raise "Failed to list packages in Gemfile: #{@gemfile_path.inspect}\nReason:\n#{output}"
-        end
-      end
-      extract_packages(output)
+    def gem_names
+      extract_gem_names(bundle_list(@gemfile_path))
     end
 
     protected
 
-    def extract_packages(output)
+    def bundle_list(gemfile_path)
+      # after trial-and-error, these steps work best:
+      # 1. cd to dir containing the gemfile
+      # 2. bundle list
+      dir = File.expand_path(File.dirname(@gemfile_path))
+      filename = File.basename(@gemfile_path)
+      output = %x{cd '#{dir}' && BUNDLE_GEMFILE=#{filename} bundle list 2>&1}
+      successful_run = ($?.exitstatus == 0)
+
+      unless successful_run
+        raise "Cannot list gems in gemfile #{@gemfile_path.inspect}: #{output}"
+      end
+
+      output
+    end
+
+    def extract_gem_names(output)
       lines = output.split("\n")
       lines.shift # remove first line
       lines.map do |line|

data/lib/natives/host_detection/package_provider.rb

@@ -0,0 +1,83 @@
+module Natives
+  class HostDetection
+    class PackageProvider
+      COMMANDS = {
+        'aix' => 'installp',
+        'yum' => 'yum',
+        'packman' => 'packman',
+        'apt' => 'apt-get',
+        'feebsd' => 'pkg_add',
+        'portage' => 'emerge',
+        'homebrew' => 'brew',
+        'macports' => 'port',
+        'solaris' => 'pkg_add',
+        'ips' => 'pkg',
+        'zypper' => 'zypper',
+        'smartos' => 'pkgin'
+      }.freeze
+
+      PROVIDERS = {
+        'aix' => 'aix',
+        'amazon' => 'yum',
+        'arch' => 'pacman',
+        'centos' => 'yum',
+        'debian' => 'apt',
+        'fedora' => 'yum',
+        'freebsd' => 'freebsd',
+        'gcel' => 'apt',
+        'gentoo' => 'portage',
+        'linaro' => 'apt',
+        'linuxmint' => 'apt',
+        'mac_os_x' => ['homebrew', 'macports'],
+        'mac_os_x_server' => 'macports',
+        'nexentacore' => 'solaris',
+        'omnios' => 'ips',
+        'openindiana' => 'ips',
+        'opensolaris' => 'ips',
+        'opensuse' => 'zypper',
+        'oracle' => 'yum',
+        'raspbian' => 'apt',
+        'redhat' => 'yum',
+        'scientific' => 'yum',
+        'smartos' => 'smartos',
+        'solaris2' => 'ips',
+        'suse' => 'zypper',
+        'ubuntu' => 'apt',
+        'xcp' => 'yum',
+        'xenserver' => 'yum'
+      }.freeze
+
+      def initialize(platform)
+        @platform = platform
+      end
+
+      def name
+        providers = Array(PROVIDERS[@platform.name])
+        return providers.first if providers.count < 2
+
+        providers.find do |provider|
+          which(COMMANDS[provider]) != nil
+        end
+      end
+
+      protected
+
+      # copied from Chef cookbook 'apt'
+      # source: apt/libraries/helpers.rb
+      def which(cmd)
+        paths = (
+          ENV['PATH'].split(::File::PATH_SEPARATOR) +
+          %w(/bin /usr/bin /sbin /usr/sbin /opt/local/bin)
+        )
+
+        paths.each do |path|
+          possible = File.join(path, cmd)
+          return possible if File.executable?(possible)
+        end
+
+        nil
+      end
+
+    end
+  end
+end

data/lib/natives/host_detection/platform.rb

@@ -0,0 +1,34 @@
+require 'ohai'
+
+module Natives
+  class HostDetection
+    class Platform
+
+      def initialize
+        @ohai = build_ohai
+      end
+
+      def name
+        ohai_hash[:platform]
+      end
+
+      def version
+        ohai_hash[:platform_version]
+      end
+
+      def ohai_hash
+        @ohai
+      end
+
+      protected
+
+      def build_ohai
+        ohai = Ohai::System.new
+        ohai.require_plugin 'os'
+        ohai.require_plugin 'platform'
+        ohai
+      end
+
+    end
+  end
+end

data/lib/natives/host_detection.rb

@@ -0,0 +1,25 @@
+require 'natives/host_detection/platform'
+require 'natives/host_detection/package_provider'
+
+module Natives
+  class HostDetection
+
+    def initialize(opts={})
+      @detect_platform = opts.fetch(:detect_platform) { Platform.new }
+      @detect_package_provider = opts.fetch(:detect_package_provider) {
+        PackageProvider.new(@detect_platform) }
+    end
+
+    def platform
+      @detect_platform.name
+    end
+
+    def platform_version
+      @detect_platform.version
+    end
+
+    def package_provider
+      @detect_package_provider.name
+    end
+  end
+end

data/lib/natives.rb

@@ -0,0 +1 @@
+require 'natives/apps'

data/spec/fixtures/dir_with_matching_files/invalid1.yml

@@ -0,0 +1,9 @@
+rubygems:
+  invalid_line
+    ubuntu/apt:
+      default:
+        - imagemagick
+        - libmagick9-dev
+  curb:
+    default:
+      - curl

data/spec/fixtures/dir_with_matching_files/valid1.yaml

@@ -0,0 +1,21 @@
+rubygems:
+  capybara-webkit:
+    mac_os_x/macports:
+      default:
+        - qt4-mac-devel
+    mac_os_x/homebrew:
+      default:
+        - qt
+    ubuntu/apt:
+      default:
+        - libqtwebkit-dev
+      [10.04,10.04.1,10.04.2,10.04.3,10.04.4]:
+        - libqt4-dev
+  rmagick:
+    mac_os_x/homebrew:
+      default:
+        - imagemagick
+    ubuntu/apt:
+      default:
+        - imagemagick
+        - libmagick9-dev

data/spec/fixtures/dir_with_matching_files/valid2.yml

@@ -0,0 +1,9 @@
+rubygems:
+  rmagick:
+    ubuntu/apt:
+      default:
+        - imagemagick
+        - libmagick9-dev
+  curb:
+    default:
+      - curl

data/spec/natives/apps/detect_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'natives/apps/detect'
+
+describe Natives::Apps::Detect do
+  it "detects host's platform and package provider info" do
+    app = Natives::Apps::Detect.new
+
+    host_detection = double()
+    host_detection.stub(platform: 'ubuntu')
+    host_detection.stub(platform_version: '12.3.2')
+    host_detection.stub(package_provider: 'apt')
+    app.should_receive(:new_host_detection).
+      and_return(host_detection)
+
+    expect(app.detection_info).to eq([
+      'platform: ubuntu',
+      'platform_version: 12.3.2',
+      'package_provider: apt'
+    ].join("\n"))
+  end
+
+  it "uses HostDetection" do
+    app = Natives::Apps::Detect.new
+    expect(app.new_host_detection).to be_kind_of Natives::HostDetection
+  end
+end

data/spec/natives/apps/list_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'natives/apps/list'
+
+describe Natives::Apps::List do
+  context "given catalog entry names" do
+    it "lists native packages" do
+      catalog_name = 'rubygems'
+      entry_names = %w(sqlite3 capybara-webkit nokogiri curb)
+
+      catalog = double()
+      catalog.should_receive(:native_packages_for).
+        with(entry_names).
+        and_return(%w(foo bar spam))
+
+      host_detection = double()
+      host_detection.should_receive(:platform)
+      host_detection.should_receive(:platform_version)
+      host_detection.should_receive(:package_provider)
+
+      list = Natives::Apps::List.new
+      list.stub(new_catalog: catalog)
+      list.stub(new_host_detection: host_detection)
+
+      packages = list.natives_for(catalog_name, entry_names)
+
+      expect(packages).to eq %w(foo bar spam)
+    end
+  end
+
+  context "given a gemfile path" do
+    it "lists native packages" do
+      gemfile_path = 'path/to/gemfile'
+      list = Natives::Apps::List.new
+
+      gemfile_viewer = double()
+      gemfile_viewer.should_receive(:gem_names).
+        and_return(%w(gem1 gem2 gem3))
+
+      host_detection = double()
+      host_detection.should_receive(:platform)
+      host_detection.should_receive(:platform_version)
+      host_detection.should_receive(:package_provider)
+
+      catalog = double()
+      catalog.should_receive(:native_packages_for).
+        with(%w(gem1 gem2 gem3)).
+        and_return(%w(foo bar spam))
+
+      list.stub(new_gemfile_viewer: gemfile_viewer)
+      list.stub(new_catalog: catalog)
+      list.stub(new_host_detection: host_detection)
+
+      packages= list.natives_for_gemfile(gemfile_path)
+
+      expect(packages).to eq %w(foo bar spam)
+    end
+  end
+end

data/spec/natives/catalog/loader_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'natives/catalog/loader'
+
+describe Natives::Catalog::Loader do
+  describe "#load_from_paths" do
+    let(:loader) { Natives::Catalog::Loader.new }
+
+    it "loads files in catalog paths, in the order of given paths and sorted filenames" do
+      files = {
+        '/to/path1' => ['/to/path1/file1.yaml'],
+        '/to/path2' => ['/to/path2/file2.yaml', '/to/path2/file1.yaml'],
+        '/to/path3' => ['/to/path3/file2.yaml', '/to/path3/file1.yaml', '/to/path3/file3.yaml']
+      }
+      catalog_hashes = {
+        '/to/path1/file1.yaml' => {"rubygems" => { "p" => "p1f1", "p1" => "p1f1", "p1f1" => "" } },
+        '/to/path2/file1.yaml' => {"rubygems" => { "p" => "p2f1", "p2" => "p2f1", "p2f1" => "" } },
+        '/to/path2/file2.yaml' => {"rubygems" => { "p" => "p2f2", "p2" => "p2f2", "p2f2" => "" } },
+        '/to/path3/file1.yaml' => {"rubygems" => { "p" => "p3f1", "p3" => "p3f1", "p3f1" => "" } },
+        '/to/path3/file2.yaml' => {"rubygems" => { "p" => "p3f2", "p3" => "p3f2", "p3f2" => "" } },
+        '/to/path3/file3.yaml' => {"rubygems" => { "p" => "p3f3", "p3" => "p3f3", "p3f3" => "" } }
+      }
+      loader.stub(:yaml_files_in_path) { |path| files[path] }
+      loader.stub(:load_yaml_file) {|file| catalog_hashes[file] }
+
+      given_catalog_paths = ['/to/path3', '/to/path1', '/to/path2']
+      expected_hash = {
+        "rubygems" => {
+          "p" => "p2f2",
+          "p1" => "p1f1",
+          "p2" => "p2f2",
+          "p3" => "p3f3",
+          "p1f1" => "",
+          "p2f1" => "",
+          "p2f2" => "",
+          "p3f1" => "",
+          "p3f2" => "",
+          "p3f3" => ""
+        }
+      }
+
+      actual_hash = loader.load_from_paths(given_catalog_paths)
+      expect(actual_hash).to include(expected_hash)
+    end
+
+  end
+
+  describe "#yaml_files_in_path" do
+    let(:loader) { Natives::Catalog::Loader.new }
+
+    it "returns a list of *.yml *.yaml filenames in the given path" do
+      path = File.join(RSpec.configuration.fixture_path, 'dir_with_matching_files')
+      filenames = loader.yaml_files_in_path(path)
+      expected_filenames = [
+        File.join(path, 'invalid1.yml'),
+        File.join(path, 'valid1.yaml'),
+        File.join(path, 'valid2.yml')
+      ]
+      expect(filenames.sort).to eq(expected_filenames.sort)
+    end
+
+    it "returns empty list if there is no matching file in the given path" do
+      path = File.join(RSpec.configuration.fixture_path, 'dir_without_matching_file')
+      filenames = loader.yaml_files_in_path(path)
+      expect(filenames).to eq([])
+    end
+
+    it "returns empty list if the given path does not exist" do
+      path = File.join(RSpec.configuration.fixture_path, 'dir_not_exists')
+      filenames = loader.yaml_files_in_path(path)
+      expect(filenames).to eq([])
+    end
+  end
+
+  describe "#load_yaml_file" do
+    let(:loader) { Natives::Catalog::Loader.new }
+
+    it "loads the given file as YAML" do
+      valid_file = File.join(RSpec.configuration.fixture_path,
+        'dir_with_matching_files', 'valid1.yaml')
+
+      hash = loader.load_yaml_file(valid_file)
+
+      expect(hash).to include("rubygems")
+    end
+
+    it "raises error when the given file contains invalid YAML" do
+      valid_file = File.join(RSpec.configuration.fixture_path,
+        'dir_with_matching_files', 'invalid1.yml')
+
+      expect {
+        loader.load_yaml_file(valid_file)
+      }.to raise_error
+    end
+
+    it "raises error when the given file does not exist" do
+      expect {
+        loader.load_yaml_file("file_not_exists.yaml")
+      }.to raise_error
+    end
+  end
+end

data/spec/natives/catalog/merger_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'natives/catalog/merger'
+
+describe Natives::Catalog::Merger do
+
+  describe "#merge_catalog!" do
+    let(:merger) { Natives::Catalog::Merger.new }
+
+    it "validates both master_hash and hash_to_merge" do
+      master_hash = {}
+      hash_to_merge = {"rubygems" => {}}
+      validator = double("Natives::Catalog::Validator")
+      merger = Natives::Catalog::Merger.new(validator: validator)
+
+      validator.should_receive(:ensure_valid_catalog_groups).with(master_hash)
+      validator.should_receive(:ensure_valid_catalog_groups).with(hash_to_merge)
+
+      merger.merge_catalog!(master_hash, hash_to_merge)
+    end
+
+    it "returns master_hash" do
+      master_hash = {}
+      expect(merger.merge_catalog!(master_hash, {})).to equal(master_hash)
+    end
+
+    it "adds new catalog group into master_hash" do
+      master_hash = {}
+      hash_to_merge = {"rubygems" => {}}
+
+      merger.merge_catalog!(master_hash, hash_to_merge)
+
+      expect(master_hash).to include("rubygems" => {})
+    end
+
+    it "adds new entries into existing catalog group" do
+      master_hash = {"rubygems" => { "curb" => {} }}
+      hash_to_merge = {"rubygems" => { "nokogiri" => {} }}
+
+      merger.merge_catalog!(master_hash, hash_to_merge)
+
+      expect(master_hash).to include(
+        "rubygems" => {"curb" => {}, "nokogiri" => {}})
+    end
+
+    it "replaces existing entries in existing catalog group" do
+      master_hash = {"rubygems" => {
+                         "webkit-capybara" => {},
+                         "curb" => {} }}
+      hash_to_merge = {"rubygems" => {
+                         "curb" => {"foo" => "bar"}, "nokogiri" => {} }}
+
+      merger.merge_catalog!(master_hash, hash_to_merge)
+
+      expect(master_hash).to include(
+        "rubygems" => {
+          "webkit-capybara" => {},
+          "curb" => {"foo" => "bar"}, "nokogiri" => {}})
+    end
+  end
+end