wright 0.0.1 → 0.1.0

data/lib/wright/util/file.rb

@@ -0,0 +1,258 @@
+# The file mode conversion functions in this file are based on those
+# of Ruby's FileUtils, more specifically some methods found in
+# lib/fileutils.rb in MRI 2.1.1.
+#
+# The following is a verbatim copy of the original license:
+#
+#   Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+#
+#   Redistribution and use in source and binary forms, with or without
+#   modification, are permitted provided that the following conditions
+#   are met:
+#   1. Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#   2. Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+#   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+#   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+#   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+#   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+#   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+#   OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+#   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+#   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+#   OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+#   SUCH DAMAGE.
+
+module Wright #:nodoc:
+  module Util
+    # Internal: Various file methods.
+    module File
+      USER_MAP = { #:nodoc:
+        'u' => 04700,
+        'g' => 02070,
+        'o' => 01007,
+        'a' => 07777
+      }
+      private_constant :USER_MAP
+
+      def self.user_mask(target)
+        target.chars.reduce(0) { |a, e| a | USER_MAP[e] }
+      end
+      private_class_method :user_mask
+
+      MODE_MAP = { #:nodoc:
+        'r' => 0444,
+        'w' => 0222,
+        'x' => 0111,
+        's' => 06000,
+        't' => 01000
+      }
+      private_constant :MODE_MAP
+
+      def self.mode_mask(mode, is_directory)
+        mode.gsub!('X', 'x') if is_directory
+        mode.chars.reduce(0) { |a, e| a | MODE_MAP[e].to_i }
+      end
+      private_class_method :mode_mask
+
+      # Internal: Convert a symbolic mode string to an integer mode
+      # value.
+      #
+      # mode - The symbolic mode string.
+      # base_mode - The integer base mode.
+      # filetype - The filetype. Defaults to :file.
+      #
+      # Examples
+      #
+      #   Wright::Util::File.symbolic_mode_to_i('u=rw,go=r', 0400).to_s(8)
+      #   # => "644"
+      #
+      #   Wright::Util::File.symbolic_mode_to_i('u=rw,g+r', 0200).to_s(8)
+      #   # => "640"
+      #
+      # Returns the integer mode.
+      def self.symbolic_mode_to_i(mode, base_mode, filetype = :file)
+        is_directory = (filetype == :directory)
+        unless symbolic_mode?(mode)
+          fail ArgumentError, "Invalid file mode \"#{mode}\""
+        end
+        mode_i = base_mode
+        mode.split(/,/).each do |mode_clause|
+          mode_i = mode_clause_to_i(mode_clause, mode_i, is_directory)
+        end
+        mode_i
+      end
+
+      # Internal: Convert a single symbolic mode clause to an integer
+      # mode value.
+      #
+      # mode_clause - The symbolic mode clause.
+      # base_mode_i - The integer base mode.
+      # is_directory - Denotes whether the mode_clause should be
+      #                treated as a symbolic directory mode clause.
+      #
+      # Examples
+      #
+      #   Wright::Util::File.mode_clause_to_i('g+r', 0600, false).to_s(8)
+      #   # => "640"
+      #
+      #   Wright::Util::File.mode_clause_to_i('+rw', 0600, false).to_s(8)
+      #   # => "666"
+      #
+      # Returns the mode clause as an integer.
+      def self.mode_clause_to_i(mode_clause, base_mode_i, is_directory)
+        mode_clause = "a#{mode_clause}" if mode_clause =~ /\A[+-=]/
+        who, op, perm = mode_clause.split(/([+-=])/)
+        perm ||= ''
+        user_mask = user_mask(who)
+        mode_mask = mode_mask(perm, is_directory)
+        apply_user_mode_masks(base_mode_i, user_mask, op, mode_mask)
+      end
+      private_class_method :mode_clause_to_i
+
+      def self.apply_user_mode_masks(base_mode_i, user_mask, op, mode_mask)
+        case op
+        when '='
+          (base_mode_i & ~user_mask) | (user_mask & mode_mask)
+        when '+'
+          base_mode_i | (user_mask & mode_mask)
+        when '-'
+          base_mode_i & ~(user_mask & mode_mask)
+        end
+      end
+      private_class_method :apply_user_mode_masks
+
+      # Internal: Convert a numeric mode string to an integer mode.
+      #
+      # mode - The numeric mode string.
+      #
+      # Examples
+      #
+      #   Wright::Util::File.numeric_mode_to_i('0600').to_s(8)
+      #   # => "600"
+      #
+      #   Wright::Util::File.numeric_mode_to_i('644').to_s(8)
+      #   # => "644"
+      #
+      #   Wright::Util::File.numeric_mode_to_i(0644).to_s(8)
+      #   # => "644"
+      #
+      #   Wright::Util::File.numeric_mode_to_i('invalid_mode').to_s(8)
+      #   # => nil
+      #
+      # Returns the mode in integer form or nil if the mode could not
+      # be converted.
+      def self.numeric_mode_to_i(mode)
+        return mode.to_i unless mode.is_a?(String)
+        mode =~ /\A[0-7]{3,4}\Z/ ? mode.to_i(8) : nil
+      end
+
+      def self.symbolic_mode?(mode_str)
+        return true if mode_str.empty?
+        mode_fragment = /([augo]*[+-=][rwxXst]*)/
+        mode_re = /\A#{mode_fragment}(,#{mode_fragment})*\Z/
+        !(mode_str =~ mode_re).nil?
+      end
+      private_class_method :symbolic_mode?
+
+      # Internal: Get a file's current mode.
+      #
+      # path - The file's path.
+      #
+      # Examples
+      #
+      #   FileUtils.touch('foo')
+      #   FileUtils.chmod(0644, 'foo')
+      #   Wright::Util::File.file_mode('foo').to_s(8)
+      #   # => "644"
+      #
+      # Returns the file mode as an integer or nil if the file does
+      # not exist.
+      def self.file_mode(path)
+        ::File.exist?(path) ? (::File.stat(path).mode & 07777) : nil
+      end
+
+      # Internal: Get a file's owner.
+      #
+      # path - The file's path.
+      #
+      # Examples
+      #
+      #   FileUtils.touch('foo')
+      #   FileUtils.chown(0, 0, 'foo')
+      #   Wright::Util::File.file_owner('foo')
+      #   # => 0
+      #
+      #   Wright::Util::File.file_owner('nonexistent')
+      #   # => nil
+      #
+      # Returns the file owner's uid or nil if the file does not
+      # exist.
+      def self.file_owner(path)
+        ::File.exist?(path) ? ::File.stat(path).uid : nil
+      end
+
+      # Internal: Get a file's owner.
+      #
+      # path - The file's path.
+      #
+      # Examples
+      #
+      #   FileUtils.touch('foo')
+      #   FileUtils.chown(0, 0, 'foo')
+      #   Wright::Util::File.file_group('foo')
+      #   # => 0
+      #
+      #   Wright::Util::File.file_group('nonexistent')
+      #   # => nil
+      #
+      # Returns the file owner's uid or nil if the file does not
+      # exist.
+      def self.file_group(path)
+        ::File.exist?(path) ? ::File.stat(path).gid : nil
+      end
+
+      # Internal: Expand tilde symbols in file paths. Path elements
+      # other than the first one are left alone.
+      #
+      # path - The file path.
+      #
+      # Examples
+      #
+      #   Wright::Util::File.expand_tilde_path('~root/foo')
+      #   # => "/root/foo"
+      #
+      #   Wright::Util::File.expand_tilde_path('~root/foo/..')
+      #   # => "/root/foo/.."
+      #
+      #   Wright::Util::File.expand_tilde_path('../foo/bar')
+      #   # => "../foo/bar"
+      #
+      # Returns the expanded String path.
+      def self.expand_tilde_path(path)
+        return path unless path.start_with?('~')
+
+        first, *rest = path.split(::File::SEPARATOR)
+        ::File.join(::File.expand_path(first), rest)
+      end
+
+      # Internal: Creates a link named link_name to target.
+      #
+      # If the file denoted by link_name is a symlink to a directory,
+      # ln_sfn does not descend into it. Behaves similar to GNU ln(1) or
+      # OpenBSD ln(1) when using "ln -sfn to link_name".
+      #
+      # Returns nothing.
+      def self.ln_sfn(target, link_name)
+        if ::File.symlink?(link_name) && ::File.directory?(link_name)
+          FileUtils.rm(link_name)
+        end
+        FileUtils.ln_sf(target, link_name)
+      end
+    end
+  end
+end

data/lib/wright/util/file_permissions.rb

@@ -0,0 +1,129 @@
+require 'wright/util/file'
+require 'wright/util/user'
+
+module Wright
+  module Util
+    # Internal: Helper class to manage file permissions.
+    class FilePermissions
+      # Internal: Create a FilePermissions from a Wright::Resource.
+      #
+      # resource - The resource object.
+      # filetype - The file's type, typically :file or :directory.
+      #
+      # Returns a Wright::Util::FilePermissions object.
+      def self.create_from_resource(resource, filetype)
+        filepath = ::File.expand_path(resource.name)
+        p = Wright::Util::FilePermissions.new(filepath, filetype)
+        p.owner = resource.owner
+        p.group = resource.group
+        p.mode = resource.mode
+        p
+      end
+
+      # Internal: Get/Set the target file's name.
+      attr_accessor :filename
+
+      # Internal: Get/Set the file's target group.
+      attr_accessor :group
+
+      # Internal: Get/Set the file's target mode.
+      attr_accessor :mode
+
+      # Internal: Get the file's target owner.
+      attr_reader :owner
+
+      # Internal: Supported filetypes.
+      VALID_FILETYPES = [:file, :directory]
+
+      # Internal: Initialize a FilePermissions object.
+      #
+      # filename - The file's name.
+      # filetype - The file's type, typically :file or :directory.
+      def initialize(filename, filetype)
+        unless VALID_FILETYPES.include?(filetype)
+          fail ArgumentError, "Invalid filetype '#{filetype}'"
+        end
+        @filename = filename
+        @filetype = filetype
+      end
+
+      # Internal: Set the file's owner.
+      def owner=(owner)
+        @owner = Util::User.user_to_uid(owner)
+      end
+
+      # Internal: Set the file's group
+      def group=(group)
+        @group = Util::User.group_to_gid(group)
+      end
+
+      # Internal: Set the file's mode.
+      def mode=(mode)
+        if mode.nil?
+          @mode = nil
+          return
+        end
+
+        mode_i = File.numeric_mode_to_i(mode)
+        unless mode_i
+          base_mode_i = ::File.exist?(@filename) ? current_mode : default_mode
+          mode_i = File.symbolic_mode_to_i(mode, base_mode_i, @filetype)
+        end
+        @mode = mode_i
+      end
+
+      # Internal: Check if the file's owner, group and mode are up-to-date.
+      def uptodate?
+        if ::File.exist?(@filename)
+          owner_uptodate? && group_uptodate? && mode_uptodate?
+        else
+          false
+        end
+      end
+
+      # Internal: Update the file's owner, group and mode.
+      def update
+        ::File.chmod(@mode, @filename) if @mode
+        ::File.chown(@owner, @group, @filename) if @owner || @group
+      end
+
+      # Internal: Get the file's current mode.
+      def current_mode
+        Wright::Util::File.file_mode(@filename)
+      end
+
+      # Internal: Get the file's current owner.
+      def current_owner
+        Wright::Util::File.file_owner(@filename)
+      end
+
+      # Internal: Get the file's current group.
+      def current_group
+        Wright::Util::File.file_group(@filename)
+      end
+
+      private
+
+      def owner_uptodate?
+        @owner.nil? || current_owner == @owner
+      end
+
+      def group_uptodate?
+        @group.nil? || current_group == @group
+      end
+
+      def mode_uptodate?
+        @mode.nil? || current_mode == @mode
+      end
+
+      def default_mode
+        case @filetype
+        when :file
+          ~::File.umask & 0666
+        when :directory
+          ~::File.umask & 0777
+        end
+      end
+    end
+  end
+end

data/lib/wright/util/recursive_autoloader.rb

@@ -0,0 +1,91 @@
+require 'wright/util'
+
+module Wright
+  module Util
+    # Internal: Recursive autoloader, recursively adds autoloads for
+    # all files in a directory.
+    module RecursiveAutoloader
+      # Internal: Adds autoloads for all files in a directory to a
+      # parent class.
+      #
+      # Registers all files in directory to be autoloaded the
+      # first time ParentClass::CamelCased::FileName is accessed.
+      #
+      # directory - The path of the directory containing the files to
+      #             be autoloaded.
+      #
+      # parent_class - The parent class to add the autoloads to.
+      #
+      # Examples
+      #
+      #   require 'fileutils'
+      #
+      #   # set up a test directory
+      #   FileUtils.cd '/tmp'
+      #   FileUtils.mkdir_p 'somedir/foo'
+      #   File.write('somedir/foo/bar_baz.rb', 'class Root::Foo::BarBaz; end')
+      #
+      #   # define a root class, add an autoload
+      #   class Root; end
+      #   Wright::Util::RecursiveAutoloader.add_autoloads('somedir', 'Root')
+      #
+      #   # Root::Foo::BarBaz is going to be autoloaded
+      #   Root::Foo.autoload? 'BarBaz'
+      #   # => "/tmp/somedir/foo/bar_baz.rb"
+      #
+      #   # instantiate Root::Foo::BarBaz, somedir/foo/bar_baz.rb is loaded
+      #   foo_bar_baz = Root::Foo::BarBaz.new
+      #   foo_bar_baz.class
+      #   # => Root::Foo::BarBaz
+      #
+      #   # at this point, somedir/foo/bar_baz.rb has already been loaded
+      #   Root::Foo.autoload? 'BarBaz'
+      #   # => nil
+      #
+      # Returns nothing.
+      # Raises ArgumentError if the parent class cannot be resolved.
+      def self.add_autoloads(directory, parent_class)
+        unless class_exists?(parent_class)
+          fail ArgumentError, "Can't resolve parent_class #{parent_class}"
+        end
+        add_autoloads_unsafe(directory, parent_class)
+      end
+
+      def self.add_autoloads_for_current_dir(parent_class)
+        klass = Wright::Util::ActiveSupport.constantize(parent_class)
+        Dir['*.rb'].each do |filename|
+          classname = "#{Wright::Util.filename_to_classname(filename)}"
+          klass.autoload classname, ::File.expand_path(filename)
+        end
+      end
+      private_class_method :add_autoloads_for_current_dir
+
+      def self.ensure_subclass_exists(classname, subclass)
+        complete_classname = "#{classname}::#{subclass}"
+        return true if class_exists?(complete_classname)
+        klass = Wright::Util::ActiveSupport.constantize(classname)
+        klass.const_set(subclass, Class.new)
+      end
+      private_class_method :ensure_subclass_exists
+
+      def self.class_exists?(classname)
+        !Wright::Util::ActiveSupport.safe_constantize(classname).nil?
+      end
+      private_class_method :class_exists?
+
+      def self.add_autoloads_unsafe(directory, parent_class)
+        Dir.chdir(directory) do
+          add_autoloads_for_current_dir(parent_class)
+          Dir['*/'].each do |dir|
+            subclass = Wright::Util.filename_to_classname(dir)
+            ensure_subclass_exists(parent_class, subclass)
+            new_parent = Wright::Util.filename_to_classname(
+                                           ::File.join(parent_class, dir))
+            add_autoloads_unsafe(dir, new_parent)
+          end
+        end
+      end
+      private_class_method :add_autoloads_unsafe
+    end
+  end
+end

data/lib/wright/util/stolen_from_activesupport.rb

@@ -0,0 +1,202 @@
+# The functions in this file are based on Ruby on Rails' ActiveSupport
+# toolkit, more specifically the Inflector module of Rails 4 found in
+# activesupport/lib/active_support/inflector/methods.rb.
+#
+# The following is a verbatim copy of the original license:
+#
+#   Copyright (c) 2005-2014 David Heinemeier Hansson
+#
+#   Permission is hereby granted, free of charge, to any person obtaining
+#   a copy of this software and associated documentation files (the
+#   "Software"), to deal in the Software without restriction, including
+#   without limitation the rights to use, copy, modify, merge, publish,
+#   distribute, sublicense, and/or sell copies of the Software, and to
+#   permit persons to whom the Software is furnished to do so, subject to
+#   the following conditions:
+#
+#   The above copyright notice and this permission notice shall be
+#   included in all copies or substantial portions of the Software.
+#
+#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Wright #:nodoc:
+  module Util
+    # Internal: Various methods copied verbatim from ActiveSupport in
+    #   order to keep dependencies to a minimum.
+    module ActiveSupport
+      # Internal: Convert a CamelCased String to underscored,
+      #   lowercase form.
+      #
+      # Changes '::' to '/' to convert namespaces to paths.
+      #
+      # camel_cased_word - The String to be underscored.
+      #
+      # Examples
+      #
+      #   underscore("ActiveModel")
+      #   # => "active_model"
+      #
+      #   underscore("ActiveModel::Errors")
+      #   # => "active_model/errors"
+      #
+      # As a rule of thumb you can think of underscore as the inverse
+      # of camelize, though there are cases where that does not hold:
+      #
+      #   camelize(underscore("SSLError"))
+      #   # => "SslError"
+      #
+      # Returns the underscored String.
+      def self.underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        word.tr!('-', '_')
+        word.downcase!
+        word
+      end
+
+      # Internal: Convert an underscored_string to UpperCamelCase.
+      #
+      # camelize will also convert '/' to '::' which is useful for
+      #   converting paths to namespaces.
+      #
+      # s - The String to be camelized.
+      #
+      # Examples
+      #
+      #   camelize("active_record")
+      #   # => "ActiveRecord"
+      #
+      #   camelize("active_record/errors")
+      #   # => "ActiveRecord::Errors"
+      #
+      # As a rule of thumb you can think of camelize as the inverse of
+      # underscore, though there are cases where that does not hold:
+      #
+      #   camelize(underscore("SSLError"))
+      #   # => "SslError"
+      #
+      # Returns the camelized String.
+      def self.camelize(s)
+        s.to_s
+          .gsub(/\/(.?)/) { "::#{Regexp.last_match[1].upcase}" }
+          .gsub(/(?:^|_)(.)/) { Regexp.last_match[1].upcase }
+      end
+
+      # Internal: Find a constant with the name specified in the
+      # argument string.
+      #
+      # camel_cased_word - The String name of the constant to find.
+      #
+      # Examples
+      #
+      #   constantize("Module")
+      #   # => Module
+      #
+      #   constantize("Test::Unit")
+      #   # => Test::Unit
+      #
+      # The name is assumed to be the one of a top-level constant, no
+      # matter whether it starts with "::" or not. No lexical context
+      # is taken into account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C                # => 'inside'
+      #     constantize("C") # => 'outside', same as ::C
+      #   end
+      #
+      # Returns the constant.
+      # Raises NameError if the constant name is not in CamelCase or
+      #   the constant is unknown.
+      def self.constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        c = Object
+        names.each do |name|
+          const_defined = c.const_defined?(name, false)
+          c = const_defined ? c.const_get(name) : c.const_missing(name)
+        end
+        c
+      end
+
+      # Internal: Find a constant with the name specified in the
+      # argument string.
+      #
+      # camel_cased_word - The String name of the constant to find.
+      #
+      # Examples
+      #
+      #   constantize("Module")
+      #   # => Module
+      #
+      #   constantize("Test::Unit")
+      #   # => Test::Unit
+      #
+      # The name is assumed to be the one of a top-level constant, no
+      # matter whether it starts with "::" or not. No lexical context
+      # is taken into account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C                # => 'inside'
+      #     constantize("C") # => 'outside', same as ::C
+      #   end
+      #
+      # nil is returned when the name is not in CamelCase or the
+      # constant (or part of it) is unknown.
+      #
+      #   safe_constantize("blargle")
+      #   # => nil
+      #
+      #   safe_constantize("UnknownModule")
+      #   # => nil
+      #
+      #   safe_constantize("UnknownModule::Foo::Bar")
+      #   # => nil
+      #
+      # Returns the constant or nil if the name is not in CamelCase or
+      #   the constant is unknown.
+      def self.safe_constantize(camel_cased_word)
+        constantize(camel_cased_word)
+      rescue NameError => e
+        error_re = /(uninitialized constant|wrong constant name)/
+        const_re = const_regexp(camel_cased_word)
+        message_re = /#{error_re} #{const_re}$/
+        uninitialized_constant_exception =
+          e.message =~ message_re || e.name.to_s == camel_cased_word.to_s
+        raise unless uninitialized_constant_exception
+      end
+
+      # Internal: Construct a regular expression that will match a
+      # constant part by part.
+      #
+      # camel_cased_word - The CamelCased String constant name.
+      #
+      # Examples
+      #
+      #   const_regexp("Foo::Bar::Baz")
+      #   # => "Foo(::Bar(::Baz)?)?"
+      #
+      # Returns the String to be used as a regular expression.
+      def self.const_regexp(camel_cased_word)
+        parts = camel_cased_word.split('::')
+        last  = parts.pop
+
+        parts.reverse.reduce(last) do |acc, part|
+          part.empty? ? acc : "#{part}(::#{acc})?"
+        end
+      end
+    end
+  end
+end