linebook 0.7.0 → 0.8.0

data/lib/linebook/os/posix/variable.rb

@@ -0,0 +1,91 @@
+module Linebook
+  module Os
+    module Posix
+      class Variable
+        attr_accessor :varname
+        attr_accessor :default
+
+        def initialize(varname, default=nil)
+          @varname = varname.to_s
+          @default = default
+        end
+
+        def lstrip(pattern)
+          "${#{varname}##{pattern}}"
+        end
+
+        def llstrip(pattern)
+          "${#{varname}###{pattern}}"
+        end
+
+        def rstrip(pattern)
+          "${#{varname}%#{pattern}}"
+        end
+
+        def rrstrip(pattern)
+          "${#{varname}%%#{pattern}}"
+        end
+
+        def sub(pattern, replacement)
+          "${#{varname}/#{pattern}/#{replacement}}"
+        end
+
+        def gsub(pattern, replacement)
+          "${#{varname}//#{pattern}/#{replacement}}"
+        end
+
+        def length
+          "${##{varname}}"
+        end
+
+        def substring(offset, length=nil)
+          length ? "${#{varname}:#{offset}:#{length}}": "${#{varname}:#{offset}}"
+        end
+
+        def eq(another)
+          "[ #{self} -eq #{another} ]"
+        end
+
+        def ne(another)
+          "[ #{self} -ne #{another} ]"
+        end
+
+        def gt(another)
+          "[ #{self} -gt #{another} ]"
+        end
+
+        def lt(another)
+          "[ #{self} -lt #{another} ]"
+        end
+
+        def ==(another)
+          "[ #{self} = #{another} ]"
+        end
+
+        # def !=(another)
+        #   "[ #{self} != #{another} ]"
+        # end
+
+        def >(another)
+          "[ #{self} > #{another} ]"
+        end
+
+        def <(another)
+          "[ #{self} < #{another} ]"
+        end
+
+        def null?
+          "[ -z #{self} ]"
+        end
+
+        def not_null?
+          "[ -n #{self} ]"
+        end
+
+        def to_s
+          default.nil? ? "$#{varname}" : "${#{varname}:-#{default}}"
+        end
+      end
+    end
+  end
+end

data/lib/linebook/os/ubuntu.rb

@@ -8,7 +8,7 @@ module Linebook
       
       # Installs a package using apt-get.
       def package(name, version=nil, options={:q => true, :y => true})
-        name = "#{name}=#{version}" unless blank?(version)
+        name = "#{name}=#{version}" unless version.to_s.strip.empty?
         execute "apt-get install", name, options
         chain_proxy
       end

data/lib/linebook/shell.rb

@@ -18,9 +18,9 @@ module Linebook
     
     def directory(target, options={})
       unless_ _directory?(target) do 
-        mkdir_p target
+        mkdir '-p', target
       end 
-      chmod options[:mode] || 755, target
+      chmod options[:mode] || 0755, target
       chown options[:owner], options[:group], target
       chain_proxy
     end
@@ -80,7 +80,7 @@ module Linebook
         current = target_path('tmp')
         recipe_name.split('/').each do |segment|
           current = File.join(current, segment)
-          directory current, :mode => 770
+          directory current, :mode => 0770
         end
         writeln "#{quote(recipe_path)} $*"
         check_status

data/lib/linebook/version.rb

@@ -1,6 +1,6 @@
 module Linebook
   MAJOR = 0
-  MINOR = 7
+  MINOR = 8
   TINY  = 0
 
   VERSION = "#{MAJOR}.#{MINOR}.#{TINY}"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: linebook
 version: !ruby/object:Gem::Version 
-  hash: 3
-  prerelease: 
+  hash: 63
+  prerelease: false
   segments: 
   - 0
-  - 7
+  - 8
   - 0
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-26 00:00:00 -06:00
+date: 2011-05-23 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,14 +26,14 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 11
         segments: 
         - 1
-        - 0
-        version: "1.0"
+        - 2
+        version: "1.2"
   type: :runtime
   version_requirements: *id001
-description: The standard library for Linecook, and a namespace for distributing Linecook cookbooks.
+description: The standard library for Linecook, providing helpers for POSIX and Linux.
 email: simon.a.chiang@gmail.com
 executables: []
 
@@ -43,20 +43,32 @@ extra_rdoc_files:
 - History
 - README
 - License.txt
+- HowTo/Switch Users
+- HowTo/Setup/Debian
+- HowTo/Setup/openSUSE
+- HowTo/Setup/SLES
+- HowTo/Setup/Ubuntu
 files: 
 - attributes/linebook/shell.rb
 - cookbook
 - lib/linebook.rb
 - lib/linebook/os/linux.rb
+- lib/linebook/os/linux/utilities.rb
 - lib/linebook/os/posix.rb
+- lib/linebook/os/posix/utilities.rb
+- lib/linebook/os/posix/variable.rb
 - lib/linebook/os/ubuntu.rb
-- lib/linebook/os/unix.rb
 - lib/linebook/shell.rb
 - lib/linebook/shell/bash.rb
 - lib/linebook/version.rb
 - History
 - README
 - License.txt
+- HowTo/Switch Users
+- HowTo/Setup/Debian
+- HowTo/Setup/openSUSE
+- HowTo/Setup/SLES
+- HowTo/Setup/Ubuntu
 has_rdoc: true
 homepage: http://rubygems.org/gems/linebook
 licenses: []
@@ -92,9 +104,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ""
-rubygems_version: 1.4.2
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: The Linecook standard library
+summary: The standard library for Linecook
 test_files: []
 

data/lib/linebook/os/unix.rb

@@ -1,462 +0,0 @@
-# Generated by Linecook
-
-module Linebook
-  module Os
-    module Unix
-      require 'linebook/os/posix'
-      include Posix
-      
-      def guess_target_name(source_name)
-        target_dir  = File.dirname(target_name)
-        name = File.basename(source_name)
-        
-        _package_.next_target_name(target_dir == '.' ? name : File.join(target_dir, name))
-      end
-      
-      def close
-        unless closed? 
-          if @shebang ||= false
-            section " (#{target_name}) "
-          end
-        end
-        
-        super
-      end
-      
-      # Executes 'cat' with the sources.
-      def cat(*sources)
-        execute 'cat', *sources
-        chain_proxy
-      end
-      
-      def _cat(*args, &block) # :nodoc:
-        str = capture_str { cat(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      def cd(dir=nil)
-        if block_given?
-          var = _package_.next_variable_name('cd')
-          writeln %{#{var}=$(pwd)}
-        end
-      
-        execute "cd", dir
-      
-        if block_given?
-          yield
-          execute "cd", "$#{var}"
-        end
-        chain_proxy
-      end
-      
-      def _cd(*args, &block) # :nodoc:
-        str = capture_str { cd(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Makes a command to chmod a file or directory.  Provide the mode as the
-      # literal string that should go into the statement:
-      # 
-      #   chmod "600" target
-      def chmod(mode, target)
-        if mode
-          execute 'chmod', mode, target
-        end
-        chain_proxy
-      end
-      
-      def _chmod(*args, &block) # :nodoc:
-        str = capture_str { chmod(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Makes a command to chown a file or directory.
-      def chown(user, group, target)
-        if user || group
-          execute 'chown', "#{user}:#{group}", target
-        end
-        chain_proxy
-      end
-      
-      def _chown(*args, &block) # :nodoc:
-        str = capture_str { chown(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Copy source to target.  Accepts a hash of command line options.
-      def cp(source, target, options={})
-        execute 'cp', source, target, options
-        chain_proxy
-      end
-      
-      def _cp(*args, &block) # :nodoc:
-        str = capture_str { cp(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Copy source to target, with -f.
-      def cp_f(source, target)
-        cp source, target, '-f' => true
-        chain_proxy
-      end
-      
-      def _cp_f(*args, &block) # :nodoc:
-        str = capture_str { cp_f(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Copy source to target, with -r.
-      def cp_r(source, target)
-        cp source, target, '-r'=> true
-        chain_proxy
-      end
-      
-      def _cp_r(*args, &block) # :nodoc:
-        str = capture_str { cp_r(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Copy source to target, with -rf.
-      def cp_rf(source, target)
-        cp source, target, '-rf' => true
-        chain_proxy
-      end
-      
-      def _cp_rf(*args, &block) # :nodoc:
-        str = capture_str { cp_rf(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Returns the current system time.  A format string may be provided, as well as
-      # a hash of command line options.
-      def date(format=nil, options={})
-        if format
-          format = "+#{quote(format)}"
-        end
-        
-        execute "date", format, options
-        chain_proxy
-      end
-      
-      def _date(*args, &block) # :nodoc:
-        str = capture_str { date(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      def directory?(path)
-        #  [ -d "<%= path %>" ]
-        write "[ -d \""; write(( path ).to_s); write "\" ]"
-        chain_proxy
-      end
-      
-      def _directory?(*args, &block) # :nodoc:
-        str = capture_str { directory?(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Echo the args.
-      def echo(*args)
-        execute 'echo', *args
-        chain_proxy
-      end
-      
-      def _echo(*args, &block) # :nodoc:
-        str = capture_str { echo(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      def exists?(path)
-        #  [ -e "<%= path %>" ]
-        write "[ -e \""; write(( path ).to_s); write "\" ]"
-        chain_proxy
-      end
-      
-      def _exists?(*args, &block) # :nodoc:
-        str = capture_str { exists?(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      def file?(path)
-        #  [ -f "<%= path %>" ]
-        write "[ -f \""; write(( path ).to_s); write "\" ]"
-        chain_proxy
-      end
-      
-      def _file?(*args, &block) # :nodoc:
-        str = capture_str { file?(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Sets up a gsub using sed.
-      def gsub(pattern, replacement, *args)
-        unless args.last.kind_of?(Hash)
-          args << {}
-        end
-        args.last[:e] = "s/#{pattern}/#{replacement}/g"
-        sed(*args)
-        chain_proxy
-      end
-      
-      def _gsub(*args, &block) # :nodoc:
-        str = capture_str { gsub(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Link source to target.  Accepts a hash of command line options.
-      def ln(source, target, options={})
-        execute 'ln', source, target, options
-        chain_proxy
-      end
-      
-      def _ln(*args, &block) # :nodoc:
-        str = capture_str { ln(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Copy source to target, with -s.
-      def ln_s(source, target)
-        ln source, target, '-s' => true
-        chain_proxy
-      end
-      
-      def _ln_s(*args, &block) # :nodoc:
-        str = capture_str { ln_s(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Make a directory.  Accepts a hash of command line options.
-      def mkdir(path, options={})
-        execute 'mkdir', path, options
-        chain_proxy
-      end
-      
-      def _mkdir(*args, &block) # :nodoc:
-        str = capture_str { mkdir(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Make a directory, and parent directories as needed.
-      def mkdir_p(path)
-        mkdir path, '-p' => true
-        chain_proxy
-      end
-      
-      def _mkdir_p(*args, &block) # :nodoc:
-        str = capture_str { mkdir_p(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Move source to target.  Accepts a hash of command line options.
-      def mv(source, target, options={})
-        execute 'mv', source, target, options
-        chain_proxy
-      end
-      
-      def _mv(*args, &block) # :nodoc:
-        str = capture_str { mv(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Move source to target, with -f.
-      def mv_f(source, target)
-        mv source, target, '-f' => true
-        chain_proxy
-      end
-      
-      def _mv_f(*args, &block) # :nodoc:
-        str = capture_str { mv_f(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Unlink a file.  Accepts a hash of command line options.
-      def rm(path, options={})
-        execute 'rm', path, options
-        chain_proxy
-      end
-      
-      def _rm(*args, &block) # :nodoc:
-        str = capture_str { rm(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Unlink a file or directory, with -r.
-      def rm_r(path)
-        rm path, '-r' => true
-        chain_proxy
-      end
-      
-      def _rm_r(*args, &block) # :nodoc:
-        str = capture_str { rm_r(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Unlink a file or directory, with -rf.
-      def rm_rf(path)
-        rm path, '-rf' => true
-        chain_proxy
-      end
-      
-      def _rm_rf(*args, &block) # :nodoc:
-        str = capture_str { rm_rf(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      def section(comment="")
-        n = (78 - comment.length)/2
-        str = "-" * n
-        #  #<%= str %><%= comment %><%= str %><%= "-" if comment.length % 2 == 1 %>
-        #  
-        write "#"; write(( str ).to_s); write(( comment ).to_s); write(( str ).to_s); write(( "-" if comment.length % 2 == 1 ).to_s); write "\n"
-      
-        chain_proxy
-      end
-      
-      def _section(*args, &block) # :nodoc:
-        str = capture_str { section(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Execute sed.
-      def sed(*args)
-        execute 'sed', *args
-        chain_proxy
-      end
-      
-      def _sed(*args, &block) # :nodoc:
-        str = capture_str { sed(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Sets the options to on (true) or off (false) as specified.  If a block is
-      # given then options will only be reset when the block completes.
-      def set(options)
-        if block_given?
-          var = _package_.next_variable_name('set')
-          patterns = options.keys.collect {|key| "-e #{key}" }.sort
-          writeln %{#{var}=$(set +o | grep #{patterns.join(' ')})}
-        end
-      
-        super
-      
-        if block_given?
-          yield
-          writeln %{eval "$#{var}"}
-        end
-        chain_proxy
-      end
-      
-      def _set(*args, &block) # :nodoc:
-        str = capture_str { set(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      # Sets the system time.  Must be root for this to succeed.
-      def set_date(time=Time.now) 
-        #  date -u <%= time.dup.utc.strftime("%m%d%H%M%Y.%S") %>
-        #  <% check_status %>
-        write "date -u "; write(( time.dup.utc.strftime("%m%d%H%M%Y.%S") ).to_s); write "\n"
-        check_status 
-        chain_proxy
-      end
-      
-      def _set_date(*args, &block) # :nodoc:
-        str = capture_str { set_date(*args, &block) }
-        str.strip!
-        str
-      end
-      
-      def shebang(options={})
-        @shebang = true
-        #  #!<%= options[:program] || '/bin/sh' %>
-        #  <% section %>
-        #  
-        #  usage="usage: %s: [-h]\n"
-        #  while getopts "h" opt
-        #  do
-        #    case $opt in
-        #    h  )  printf "$usage" $0
-        #          printf "       %s   %s\n" "-h" "prints this help"
-        #          exit 0 ;;
-        #    \? )  printf "$usage" $0
-        #          exit 2 ;;
-        #    esac
-        #  done
-        #  shift $(($OPTIND - 1))
-        #  
-        #  <% check_status_function %>
-        #  <% yield if block_given? %>
-        #  
-        #  <% if options[:info] %>
-        #  echo >&2
-        #  echo "###############################################################################" >&2
-        #  echo "# $(whoami)@$(hostname):$(pwd):$0" >&2
-        #  
-        #  <% end %>
-        #  <% section " #{target_name} " %>
-        #  
-        #  
-        write "#!"; write(( options[:program] || '/bin/sh' ).to_s); write "\n"
-        section 
-        write "\n"
-        write "usage=\"usage: %s: [-h]\\n\"\n"
-        write "while getopts \"h\" opt\n"
-        write "do\n"
-        write "  case $opt in\n"
-        write "  h  )  printf \"$usage\" $0\n"
-        write "        printf \"       %s   %s\\n\" \"-h\" \"prints this help\"\n"
-        write "        exit 0 ;;\n"
-        write "  \\? )  printf \"$usage\" $0\n"
-        write "        exit 2 ;;\n"
-        write "  esac\n"
-        write "done\n"
-        write "shift $(($OPTIND - 1))\n"
-        write "\n"
-        check_status_function 
-        yield if block_given? 
-        write "\n"
-        if options[:info] 
-        write "echo >&2\n"
-        write "echo \"###############################################################################\" >&2\n"
-        write "echo \"# $(whoami)@$(hostname):$(pwd):$0\" >&2\n"
-        write "\n"
-        end 
-        section " #{target_name} " 
-        write "\n"
-      
-        chain_proxy
-      end
-      
-      def _shebang(*args, &block) # :nodoc:
-        str = capture_str { shebang(*args, &block) }
-        str.strip!
-        str
-      end
-    end
-  end
-end