wright 0.2.0 → 0.3.0

data/man/wright.1

@@ -0,0 +1,202 @@
+'\" t
+.\"     Title: wright
+.\"    Author: [see the "AUTHOR" section]
+.\" Generator: DocBook XSL Stylesheets v1.78.1 <http://docbook.sf.net/>
+.\"      Date: 04/22/2015
+.\"    Manual: \ \&
+.\"    Source: \ \&
+.\"  Language: English
+.\"
+.TH "WRIGHT" "1" "04/22/2015" "\ \&" "\ \&"
+.\" -----------------------------------------------------------------
+.\" * Define some portability stuff
+.\" -----------------------------------------------------------------
+.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+.\" http://bugs.debian.org/507673
+.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
+.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+.ie \n(.g .ds Aq \(aq
+.el       .ds Aq '
+.\" -----------------------------------------------------------------
+.\" * set default formatting
+.\" -----------------------------------------------------------------
+.\" disable hyphenation
+.nh
+.\" disable justification (adjust text to left margin only)
+.ad l
+.\" -----------------------------------------------------------------
+.\" * MAIN CONTENT STARTS HERE *
+.\" -----------------------------------------------------------------
+.SH "NAME"
+wright \- lightweight config management utility
+.SH "SYNOPSIS"
+.sp
+\fBwright\fR [\fIOPTIONS\fR] \fIFILE\fR [\fIARGUMENT\fR\&...]
+.sp
+\fBwright\fR [\fIOPTIONS\fR] \fB\-e\fR \fICOMMAND\fR [\fIARGUMENT\fR\&...]
+.SH "DESCRIPTION"
+.sp
+wright is a lightweight configuration management utility\&. It can be used to perform common sysadmin tasks such as installing packages, creating files, setting up groups and users and so on by running short Ruby scripts\&.
+.sp
+Although wright is typically used to run script files, it can also execute short code snippets passed on the command line\&. Another way to run wright scripts is to make your script executable and use wright as the interpreter by setting an appropriate "#!" line\&.
+.SH "OPTIONS"
+.PP
+\fB\-e\fR \fICOMMAND\fR
+.RS 4
+Run
+\fICOMMAND\fR
+as a wright script\&. When multiple commands are passed, they are joined and run in sequence\&.
+.RE
+.PP
+\fB\-v, \-\-verbose\fR
+.RS 4
+Print debugging information\&.
+.RE
+.PP
+\fB\-q, \-\-quiet\fR
+.RS 4
+Suppress non\-error output\&.
+.RE
+.PP
+\fB\-\-version\fR
+.RS 4
+Print wright version\&.
+.RE
+.SH "EXAMPLES"
+.sp
+Install tmux via the system package manager:
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+wright \-e \*(Aqpackage "tmux"\*(Aq
+.fi
+.if n \{\
+.RE
+.\}
+.sp
+Create a system user named "foobard":
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+wright \-e \*(Aquser("foobard") { |u| u\&.system = true }\*(Aq
+.fi
+.if n \{\
+.RE
+.\}
+.sp
+Create a system group named "foobard":
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+wright \-e \*(Aqgroup("foobard") { |u| u\&.system = true }\*(Aq
+.fi
+.if n \{\
+.RE
+.\}
+.sp
+Create a file named \fI/etc/issue\fR containing the current wright version:
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+wright \-e \*(Aqfile("/etc/issue") { |f| f\&.content = Wright::VERSION }\*(Aq
+.fi
+.if n \{\
+.RE
+.\}
+.sp
+Create a directory named \fI/tmp/foo/bar/baz\fR:
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+wright \-e \*(Aqdirectory "/tmp/foo/bar/baz"\*(Aq
+.fi
+.if n \{\
+.RE
+.\}
+.sp
+Create a symlink from \fI\&.bash_profile\fR to \fI\&.profile\fR in the current user\(cqs home directory:
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+wright \-e \*(Aqsymlink("~/\&.bash_profile") { |s| s\&.to = "~/\&.profile" }\*(Aq
+.fi
+.if n \{\
+.RE
+.\}
+.sp
+To install tmux and update its config file from a wright script, create the following file:
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+package \*(Aqtmux\*(Aq
+.fi
+.if n \{\
+.RE
+.\}
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+file \*(Aq/etc/tmux\&.conf\*(Aq do |f|
+  f\&.content = <<EOF
+unbind C\-b
+set \-g prefix C\-a
+bind\-key a send\-prefix
+EOF
+  f\&.mode = \*(Aq444\*(Aq
+  f\&.on_update = \-> { puts \*(AqUpdated /etc/tmux\&.conf\*(Aq }
+end
+.fi
+.if n \{\
+.RE
+.\}
+.sp
+When saved as \fIinstall\-tmux\&.rb\fR, the script can then be run via
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+wright \-\-quiet install\-tmux\&.rb
+.fi
+.if n \{\
+.RE
+.\}
+.sp
+wright can also be used as an interpreter\&. The example below creates and runs a standalone wright script:
+.sp
+.if n \{\
+.RS 4
+.\}
+.nf
+cat <<EOF > create\-dir\&.rb
+#!/usr/bin/env wright
+directory \*(Aq/tmp/foo/bar/baz\*(Aq
+EOF
+chmod +x create\-dir\&.rb
+\&./create\-dir\&.rb
+.fi
+.if n \{\
+.RE
+.\}
+.SH "AUTHOR"
+.sp
+Sebastian Boehm <sebastian@sometimesfood\&.org>
+.SH "COPYING"
+.sp
+Copyright (C) 2012\-2015 Sebastian Boehm\&. Free use of this software is granted under the terms of the MIT License (also known as the "Expat License")\&.

data/spec/cli/shebang.rb

@@ -0,0 +1,3 @@
+print 'loaded shebang.rb'
+class WrightDSLMissing < StandardError; end
+fail WrightDSLMissing unless respond_to? :package

data/spec/cli_spec.rb

@@ -0,0 +1,64 @@
+require_relative 'spec_helper'
+
+require 'wright/cli'
+require 'wright/version'
+
+main = self
+
+describe Wright::CLI do
+  before(:each) do
+    @cli = Wright::CLI.new(main)
+    @cli_dir = File.expand_path('../cli', __FILE__)
+  end
+
+  describe '#parse' do
+    before(:each) { Wright::CLI.send(:public, :parse) }
+    after(:each) { Wright::CLI.send(:private, :parse) }
+
+    it 'parses -e COMMAND' do
+      argv = %w(-e foo -e bar -- --baz)
+      @cli.parse(argv).must_equal %w(--baz)
+      @cli.send(:commands).must_equal %w(foo bar)
+    end
+
+    it 'parses --verbose' do
+      argv = ['--verbose']
+      @cli.parse(argv)
+      @cli.send(:log_level).must_equal Wright::Logger::DEBUG
+    end
+
+    it 'parses --quiet' do
+      argv = ['--quiet']
+      @cli.parse(argv)
+      @cli.send(:log_level).must_equal Wright::Logger::ERROR
+    end
+  end
+
+  describe '#run' do
+    it 'parses --version' do
+      argv = ['--version']
+      expected = "wright version #{Wright::VERSION}\n"
+
+      -> { @cli.run(argv) }.must_output expected
+    end
+
+    it 'loads files' do
+      argv = [File.join(@cli_dir, 'shebang.rb')]
+      expected = 'loaded shebang.rb'
+      -> { @cli.run(argv) }.must_output expected
+    end
+
+    it 'evals commands' do
+      argv = ['-e print :foo']
+      -> { @cli.run(argv) }.must_output 'foo'
+    end
+
+    it 'evals commands from $stdin' do
+      argv = []
+      stdin_orig = $stdin
+      $stdin = StringIO.new("print :bar\ntrue")
+      -> { @cli.run(argv) }.must_output 'bar'
+      $stdin = stdin_orig
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -22,9 +22,14 @@ describe Wright::DSL do
 
     @wright_dsl.register_resource(resource_class)
 
-    resource_name = 'resource_klass'
-    @recipe.must_respond_to(resource_name)
-    resource = @recipe.send(resource_name)
+    resource_method_name = 'resource_klass'
+    resource_name = 'just a name'
+    @recipe.must_respond_to(resource_method_name)
+
+    e = -> { @recipe.send(resource_method_name) }.must_raise ArgumentError
+    e.message.must_equal 'wrong number of arguments (0 for 1)'
+
+    resource = @recipe.send(resource_method_name, resource_name)
     resource.must_be_instance_of(resource_class)
   end
 

data/spec/provider/group/darwin_directory_service_spec.rb

@@ -6,7 +6,7 @@ require 'fakeetc'
 describe Wright::Provider::Group::DarwinDirectoryService do
   def dseditgroup(command, group_name, gid = nil, system = false)
     if command != :delete
-      gid ||= 499 if system
+      gid ||= @groups['daemon'][:gid] + 1 if system
       options = gid.nil? ? [] : ['-i', gid.to_s]
       ['dseditgroup', '-o', command.to_s, *options, group_name]
     else
@@ -45,7 +45,8 @@ describe Wright::Provider::Group::DarwinDirectoryService do
     @remove_message_debug = lambda do |group|
       "DEBUG: group already removed: '#{group}'\n"
     end
-    @groups = { 'foobar' => { gid: 42, mem: %w(foo bar) },
+    @groups = { 'daemon' => { gid: 1, mem: [] },
+                'foobar' => { gid: 42, mem: %w(foo bar) },
                 'bazqux' => { gid: 43, mem: %w(baz qux) } }
     FakeEtc.add_groups(@groups)
   end

data/spec/provider/package/apt/apt-cache_policy_abcde.stdout

@@ -0,0 +1,7 @@
+abcde:
+  Installed: 2.5.3-1
+  Candidate: 2.5.3-1
+  Version table:
+ *** 2.5.3-1 0
+        500 http://debian.inode.at/debian/ wheezy/main amd64 Packages
+        100 /var/lib/dpkg/status

data/spec/provider/package/apt/apt-cache_policy_htop.stdout

@@ -0,0 +1,6 @@
+htop:
+  Installed: (none)
+  Candidate: 1.0.1-1
+  Version table:
+     1.0.1-1 0
+        500 http://debian.inode.at/debian/ wheezy/main amd64 Packages

data/spec/provider/package/apt/apt-cache_policy_not-a-real-package.return

@@ -0,0 +1 @@
+0

data/spec/provider/package/apt_spec.rb

@@ -3,8 +3,8 @@ require_relative '../../spec_helper'
 require 'wright/provider/package/apt'
 
 describe Wright::Provider::Package::Apt do
-  def dpkg_query(pkg_name)
-    ['dpkg-query', '-s', pkg_name]
+  def apt_cache(pkg_name)
+    ['apt-cache', 'policy', pkg_name]
   end
 
   def apt_get(action, pkg_name, pkg_version = nil)
@@ -21,20 +21,6 @@ describe Wright::Provider::Package::Apt do
     apt_dir = File.join(File.dirname(__FILE__), 'apt')
     env = { 'DEBIAN_FRONTEND' => 'noninteractive' }
     @fake_capture3 = FakeCapture3.new(apt_dir, env)
-    @install_message = ->(pkg) { "INFO: install package: '#{pkg}'\n" }
-    @install_message_dry = lambda do |pkg|
-      "INFO: (would) install package: '#{pkg}'\n"
-    end
-    @install_message_debug = lambda do |pkg|
-      "DEBUG: package already installed: '#{pkg}'\n"
-    end
-    @remove_message = ->(pkg) { "INFO: remove package: '#{pkg}'\n" }
-    @remove_message_dry = lambda do |pkg|
-      "INFO: (would) remove package: '#{pkg}'\n"
-    end
-    @remove_message_debug = lambda do |pkg|
-      "DEBUG: package already removed: '#{pkg}'\n"
-    end
   end
 
   describe '#installed_versions' do
@@ -42,33 +28,21 @@ describe Wright::Provider::Package::Apt do
       pkg_name = 'abcde'
       pkg_versions = ['2.5.3-1']
       pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
+      apt_cache_cmd = apt_cache(pkg_name)
 
-      @fake_capture3.expect(dpkg_cmd)
+      @fake_capture3.expect(apt_cache_cmd)
       @fake_capture3.stub do
         pkg_provider.installed_versions.must_equal pkg_versions
       end
     end
 
     it 'should return an empty array for missing packages' do
-      pkg_name = 'vlc'
-      pkg_versions = []
-      pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
-
-      @fake_capture3.expect(dpkg_cmd)
-      @fake_capture3.stub do
-        pkg_provider.installed_versions.must_equal pkg_versions
-      end
-    end
-
-    it 'should return an empty array for removed packages' do
       pkg_name = 'htop'
       pkg_versions = []
       pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
+      apt_cache_cmd = apt_cache(pkg_name)
 
-      @fake_capture3.expect(dpkg_cmd)
+      @fake_capture3.expect(apt_cache_cmd)
       @fake_capture3.stub do
         pkg_provider.installed_versions.must_equal pkg_versions
       end
@@ -78,92 +52,47 @@ describe Wright::Provider::Package::Apt do
       pkg_name = 'not-a-real-package'
       pkg_versions = []
       pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
+      apt_cache_cmd = apt_cache(pkg_name)
 
-      @fake_capture3.expect(dpkg_cmd)
+      @fake_capture3.expect(apt_cache_cmd)
       @fake_capture3.stub do
         pkg_provider.installed_versions.must_equal pkg_versions
       end
     end
   end
 
-  describe '#install' do
-    it 'should install packages that are not currently installed' do
+  describe '#install_package' do
+    it 'should install packages' do
       pkg_name = 'htop'
       pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
       apt_cmd = apt_get(:install, pkg_name)
 
-      @fake_capture3.expect(dpkg_cmd)
       @fake_capture3.expect(apt_cmd)
       @fake_capture3.stub do
-        lambda do
-          reset_logger
-          pkg_provider.install
-          pkg_provider.updated?.must_equal true
-        end.must_output @install_message.call(pkg_name)
-      end
-    end
-
-    it 'should not try to install packages that are already installed' do
-      pkg_name = 'abcde'
-      pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
-
-      @fake_capture3.expect(dpkg_cmd)
-      @fake_capture3.stub do
-        lambda do
-          reset_logger
-          pkg_provider.install
-          pkg_provider.updated?.must_equal false
-        end.must_output @install_message_debug.call(pkg_name)
+        pkg_provider.send(:install_package)
       end
     end
 
-    it 'should install package versions that are not currently installed' do
+    it 'should install specific package versions' do
       pkg_name = 'abcde'
       pkg_version = '2.5.4-1'
       pkg_provider = package_provider(pkg_name, pkg_version)
-      dpkg_cmd = dpkg_query(pkg_name)
       apt_cmd = apt_get(:install, pkg_name, pkg_version)
 
-      @fake_capture3.expect(dpkg_cmd)
       @fake_capture3.expect(apt_cmd)
       @fake_capture3.stub do
-        lambda do
-          reset_logger
-          pkg_provider.install
-          pkg_provider.updated?.must_equal true
-        end.must_output @install_message.call(pkg_name)
-      end
-    end
-
-    it 'should not try to install package versions already installed' do
-      pkg_name = 'abcde'
-      pkg_version = '2.5.3-1'
-      pkg_provider = package_provider(pkg_name, pkg_version)
-      dpkg_cmd = dpkg_query(pkg_name)
-
-      @fake_capture3.expect(dpkg_cmd)
-      @fake_capture3.stub do
-        lambda do
-          reset_logger
-          pkg_provider.install
-          pkg_provider.updated?.must_equal false
-        end.must_output @install_message_debug.call(pkg_name)
+        pkg_provider.send(:install_package)
       end
     end
 
     it 'should raise exceptions for unknown packages' do
       pkg_name = 'not-a-real-package'
       pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
       apt_cmd = apt_get(:install, pkg_name)
 
-      @fake_capture3.expect(dpkg_cmd)
       @fake_capture3.expect(apt_cmd)
       @fake_capture3.stub do
-        e = -> { pkg_provider.install }.must_raise RuntimeError
+        e = -> { pkg_provider.send(:install_package) }.must_raise RuntimeError
         wright_error = "cannot install package '#{pkg_name}'"
         apt_error = "E: Unable to locate package #{pkg_name}"
         e.message.must_equal %(#{wright_error}: "#{apt_error}")
@@ -171,138 +100,15 @@ describe Wright::Provider::Package::Apt do
     end
   end
 
-  describe '#remove' do
-    it 'should remove packages that are currently installed' do
+  describe '#remove_package' do
+    it 'should remove packages' do
       pkg_name = 'abcde'
       pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
       apt_cmd = apt_get(:remove, pkg_name)
 
-      @fake_capture3.expect(dpkg_cmd)
       @fake_capture3.expect(apt_cmd)
       @fake_capture3.stub do
-        lambda do
-          reset_logger
-          pkg_provider.remove
-          pkg_provider.updated?.must_equal true
-        end.must_output @remove_message.call(pkg_name)
-      end
-    end
-
-    it 'should not try to remove packages that are already removed' do
-      pkg_name = 'htop'
-      pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
-
-      @fake_capture3.expect(dpkg_cmd)
-      @fake_capture3.stub do
-        lambda do
-          reset_logger
-          pkg_provider.remove
-          pkg_provider.updated?.must_equal false
-        end.must_output @remove_message_debug.call(pkg_name)
-      end
-    end
-
-    it 'should remove package versions that are currently installed' do
-      pkg_name = 'abcde'
-      pkg_version = '2.5.3-1'
-      pkg_provider = package_provider(pkg_name, pkg_version)
-      dpkg_cmd = dpkg_query(pkg_name)
-      apt_cmd = apt_get(:remove, pkg_name)
-
-      @fake_capture3.expect(dpkg_cmd)
-      @fake_capture3.expect(apt_cmd)
-      @fake_capture3.stub do
-        lambda do
-          reset_logger
-          pkg_provider.remove
-          pkg_provider.updated?.must_equal true
-        end.must_output @remove_message.call(pkg_name)
-      end
-    end
-
-    it 'should not try to remove packages that are already removed' do
-      pkg_name = 'htop'
-      pkg_version = '2.5.4-1'
-      pkg_provider = package_provider(pkg_name, pkg_version)
-      dpkg_cmd = dpkg_query(pkg_name)
-
-      @fake_capture3.expect(dpkg_cmd)
-      @fake_capture3.stub do
-        lambda do
-          reset_logger
-          pkg_provider.remove
-          pkg_provider.updated?.must_equal false
-        end.must_output @remove_message_debug.call(pkg_name)
-      end
-    end
-  end
-
-  describe 'dry_run' do
-    it 'should not actually install packages' do
-      pkg_name = 'htop'
-      pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
-
-      Wright.dry_run do
-        @fake_capture3.expect(dpkg_cmd)
-        @fake_capture3.stub do
-          lambda do
-            reset_logger
-            pkg_provider.install
-          end.must_output @install_message_dry.call(pkg_name)
-        end
-      end
-    end
-
-    it 'should not try to install packages that are already installed' do
-      pkg_name = 'abcde'
-      pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
-
-      Wright.dry_run do
-        @fake_capture3.expect(dpkg_cmd)
-        @fake_capture3.stub do
-          lambda do
-            reset_logger
-            pkg_provider.install
-            pkg_provider.updated?.must_equal false
-          end.must_output @install_message_debug.call(pkg_name)
-        end
-      end
-    end
-
-    it 'should not actually remove packages' do
-      pkg_name = 'abcde'
-      pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
-
-      Wright.dry_run do
-        @fake_capture3.expect(dpkg_cmd)
-        @fake_capture3.stub do
-          lambda do
-            reset_logger
-            pkg_provider.remove
-          end.must_output @remove_message_dry.call(pkg_name)
-        end
-      end
-    end
-
-    it 'should not try to remove packages that are already removed' do
-      pkg_name = 'htop'
-      pkg_provider = package_provider(pkg_name)
-      dpkg_cmd = dpkg_query(pkg_name)
-
-      Wright.dry_run do
-        @fake_capture3.expect(dpkg_cmd)
-        @fake_capture3.stub do
-          lambda do
-            reset_logger
-            pkg_provider.remove
-            pkg_provider.updated?.must_equal false
-          end.must_output @remove_message_debug.call(pkg_name)
-        end
+        pkg_provider.send(:remove_package)
       end
     end
   end