win32-file-attributes 1.0.0

data/CHANGES

@@ -0,0 +1,2 @@
+= 1.0.0 - 26-Nov-2012
+* Initial release as an independent library.

data/MANIFEST

@@ -0,0 +1,10 @@
+* CHANGES
+* MANIFEST
+* Rakefile
+* README
+* win32-file-attributes.gemspec
+* lib/win32/file/attributes.rb
+* lib/win32/file/windows/constants.rb
+* lib/win32/file/windows/functions.rb
+* lib/win32/file/windows/structs.rb
+* test/test_win32_file_attributes.rb

data/README

@@ -0,0 +1,46 @@
+== Description
+  Additional methods for the File class that relate to file properties
+  on the Microsoft Windows operating system.
+
+== Prerequisites
+  * ffi
+
+== Installation
+  gem install win32-file-attributes
+
+== Synopsis
+
+  require 'win32/file/attributes
+
+  p File.hidden?(file)    # => false
+  p File.attributes(file) # => ['archive', 'indexed']
+
+== Notes
+  If you have the win32-file gem already installed then you do not need this
+  gem. This library was split out from the win32-file gem in order to ease
+  testing and maintenance.
+
+  Otherwise, the only difference is that this library uses FFI instead
+  of win32-api. This also means that it works with JRuby.
+
+== Known issues or bugs
+  None that I'm aware of.
+
+  Please report any issues you find on the github page at:
+
+  https://github.com/djberg96/win32-file-attributes/issues
+  
+== License
+  Artistic 2.0
+
+== Copyright
+  (C) 2003-2012, Daniel J. Berger, All Rights Reserved
+
+== Warranty
+  This package is provided "as is" and without any express or
+  implied warranties, including, without limitation, the implied
+  warranties of merchantability and fitness for a particular purpose.
+
+== Authors
+  * Daniel J. Berger
+  * Park Heesob

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+
+CLEAN.include('**/*.gem', '**/*.rbc')
+
+namespace :gem do
+  desc 'Build the win32-file-attributes gem'
+  task :create => [:clean] do
+    spec = eval(IO.read('win32-file-attributes.gemspec'))
+    Gem::Builder.new(spec).build
+  end
+
+  desc "Install the win32-file-attributes gem"
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install #{file}"
+  end
+end
+
+Rake::TestTask.new do |t|
+  task :test => :clean
+  t.warning = true
+  t.verbose = true
+end
+
+task :default => :test

data/lib/win32/file/attributes.rb

@@ -0,0 +1,556 @@
+require File.join(File.dirname(__FILE__), 'windows', 'constants')
+require File.join(File.dirname(__FILE__), 'windows', 'structs')
+require File.join(File.dirname(__FILE__), 'windows', 'functions')
+
+class File
+  include Windows::File::Constants
+  include Windows::File::Functions
+  extend Windows::File::Constants
+  extend Windows::File::Structs
+  extend Windows::File::Functions
+
+  # The version of the win32-file library
+  WIN32_FILE_ATTRIBUTE_VERSION = '1.0.0'
+
+  ## ABBREVIATED ATTRIBUTE CONSTANTS
+
+  # The file or directory is an archive. Typically used to mark files for
+  # backup or removal.
+  ARCHIVE = FILE_ATTRIBUTE_ARCHIVE
+
+  # The file or directory is encrypted. For a file, this means that all
+  # data in the file is encrypted. For a directory, this means that
+  # encryption is # the default for newly created files and subdirectories.
+  COMPRESSED = FILE_ATTRIBUTE_COMPRESSED
+
+  # The file is hidden. Not included in an ordinary directory listing.
+  HIDDEN = FILE_ATTRIBUTE_HIDDEN
+
+  # A file that does not have any other attributes set.
+  NORMAL = FILE_ATTRIBUTE_NORMAL
+
+  # The data of a file is not immediately available. This attribute indicates
+  # that file data is physically moved to offline storage.
+  OFFLINE = FILE_ATTRIBUTE_OFFLINE
+
+  # The file is read only. Apps can read it, but not write to it or delete it.
+  READONLY = FILE_ATTRIBUTE_READONLY
+
+  # The file is part of or used exclusively by an operating system.
+  SYSTEM = FILE_ATTRIBUTE_SYSTEM
+
+  # The file is being used for temporary storage.
+  TEMPORARY = FILE_ATTRIBUTE_TEMPORARY
+
+  # The file or directory is to be indexed by the content indexing service.
+  # Note that we have inverted the traditional definition.
+  INDEXED = 0x0002000
+
+  # Synonym for File::INDEXED.
+  CONTENT_INDEXED = INDEXED
+
+  ## SINGLETON METHODS
+
+  # Returns an array of strings indicating the attributes for that file.
+  # The possible values are:
+  #
+  # archive
+  # compressed
+  # directory
+  # encrypted
+  # hidden
+  # indexed
+  # normal
+  # offline
+  # readonly
+  # reparse_point
+  # sparse
+  # system
+  # temporary
+  #
+  def self.attributes(file)
+    attributes = GetFileAttributesW(file.wincode)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    arr = []
+
+    arr << 'archive' if attributes & FILE_ATTRIBUTE_ARCHIVE > 0
+    arr << 'compressed' if attributes & FILE_ATTRIBUTE_COMPRESSED > 0
+    arr << 'directory' if attributes & FILE_ATTRIBUTE_DIRECTORY > 0
+    arr << 'encrypted' if attributes & FILE_ATTRIBUTE_ENCRYPTED > 0
+    arr << 'hidden' if attributes & FILE_ATTRIBUTE_HIDDEN > 0
+    arr << 'indexed' if attributes & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED == 0
+    arr << 'normal' if attributes & FILE_ATTRIBUTE_NORMAL > 0
+    arr << 'offline' if attributes & FILE_ATTRIBUTE_OFFLINE > 0
+    arr << 'readonly' if attributes & FILE_ATTRIBUTE_READONLY > 0
+    arr << 'reparse_point' if attributes & FILE_ATTRIBUTE_REPARSE_POINT > 0
+    arr << 'sparse' if attributes & FILE_ATTRIBUTE_SPARSE_FILE > 0
+    arr << 'system' if attributes & FILE_ATTRIBUTE_SYSTEM > 0
+    arr << 'temporary' if attributes & FILE_ATTRIBUTE_TEMPORARY > 0
+
+    arr
+  end
+
+  # Sets the file attributes based on the given (numeric) +flags+. This does
+  # not remove existing attributes, it merely adds to them. Use the
+  # File.remove_attributes method if you want to remove them.
+  #
+  # Please not that certain attributes cannot always be applied. For example,
+  # you cannot convert a regular file into a directory. Common sense should
+  # guide you here.
+  #
+  def self.set_attributes(file, flags)
+    wfile = file.wincode
+    attributes = GetFileAttributesW(wfile)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    attributes |= flags
+
+    if SetFileAttributesW(wfile, attributes) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  # Removes the file attributes based on the given (numeric) +flags+.
+  #
+  def self.remove_attributes(file, flags)
+    wfile = file.wincode
+    attributes = GetFileAttributesW(wfile)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    attributes &= ~flags
+
+    if SetFileAttributesW(wfile, attributes) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  # Returns whether or not the file or directory is an archive file or
+  # directory. Applications typically use this attribute to mark files
+  # for backup or removal.
+  #
+  def self.archive?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_ARCHIVE)
+  end
+
+  # Returns whether or not the file or directory is compressed. For a file,
+  # this means that all of the data in the file is compressed. For a directory,
+  # this means that compression is the default for newly created files and
+  # subdirectories.
+  #
+  def self.compressed?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_COMPRESSED)
+  end
+
+  # Returns whether or not the file or directory is encrypted. For a file,
+  # this means that all data in the file is encrypted. For a directory, this
+  # means that encryption is the default for newly created files and
+  # subdirectories.
+  #
+  def self.encrypted?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_ENCRYPTED)
+  end
+
+  # Returns whether or not the file or directory is hidden. A hidden file
+  # does not show up in an ordinary directory listing.
+  #
+  def self.hidden?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_HIDDEN)
+  end
+
+  # Returns whether or not the file or directory has been indexed by
+  # the content indexing service.
+  #
+  def self.indexed?(file)
+    !check_for_attribute(file, FILE_ATTRIBUTE_NOT_CONTENT_INDEXED)
+  end
+
+  # Returns whether or not the file is a normal file or directory. A normal
+  # file or directory does not have any other attributes set.
+  #
+  def self.normal?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_NORMAL)
+  end
+
+  # Returns whether or not the data of a file is available immediately.
+  # If true it indicates that the file data is physically moved to offline
+  # storage.
+  #
+  def self.offline?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_OFFLINE)
+  end
+
+  # Returns whether or not the file is read-only. If a file is read-only then
+  # applications can read the file, but cannot write to it or delete it.
+  #
+  # Note that this attribute is not honored on directories.
+  #
+  def self.readonly?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_READONLY)
+  end
+
+  # Returns true if the file or directory has an associated reparse point. A
+  # reparse point is a collection of user defined data associated with a file
+  # or directory.  For more on reparse points, search
+  # http://msdn.microsoft.com.
+  #
+  def self.reparse_point?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_REPARSE_POINT)
+  end
+
+  # Returns whether or not the file is a sparse file. A sparse file is a
+  # file in which much of the data is zeros, typically image files.
+  #
+  def self.sparse?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_SPARSE_FILE)
+  end
+
+  # Returns whether or not the file or directory is a system file. A system
+  # file is a file that is part of the operating system or is used exclusively
+  # by the operating system.
+  #
+  def self.system?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_SYSTEM)
+  end
+
+  # Returns whether or not the file is being used for temporary storage.
+  #
+  # File systems avoid writing data back to mass storage if sufficient cache
+  # memory is available, because often the application deletes the temporary
+  # file shortly after the handle is closed. In that case, the system can
+  # entirely avoid writing the data. Otherwise, the data will be written after
+  # the handle is closed.
+  #
+  def self.temporary?(file)
+    check_for_attribute(file, FILE_ATTRIBUTE_TEMPORARY)
+  end
+
+  class << self
+    alias read_only? readonly?
+    alias content_indexed? indexed?
+    alias set_attr set_attributes
+    alias unset_attr remove_attributes
+  end
+
+  ## INSTANCE METHODS
+
+  # Sets whether or not the file is an archive file. Applications typically
+  # use this attribute to mark files for backup or removal.
+  #
+  def archive=(bool)
+    wide_path  = self.path.wincode
+    attributes = GetFileAttributesW(wide_path)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    if bool
+      attributes |= FILE_ATTRIBUTE_ARCHIVE;
+    else
+      attributes &= ~FILE_ATTRIBUTE_ARCHIVE;
+    end
+
+    if SetFileAttributesW(wide_path, attributes) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  # Sets whether or not the file is a compressed file. For a file, this means
+  # that all of the data in the file is compressed. For a directory, this means
+  # that compression is the default for newly created files and subdirectories.
+  #
+  def compressed=(bool)
+    in_buf = FFI::MemoryPointer.new(:ulong)
+    bytes  = FFI::MemoryPointer.new(:ulong)
+
+    compression_value = bool ? COMPRESSION_FORMAT_DEFAULT : COMPRESSION_FORMAT_NONE
+    in_buf.write_ulong(compression_value)
+
+    # We can't use get_osfhandle here because we need specific attributes
+    handle = CreateFileW(
+      self.path.wincode,
+      FILE_READ_DATA | FILE_WRITE_DATA,
+      FILE_SHARE_READ | FILE_SHARE_WRITE,
+      nil,
+      OPEN_EXISTING,
+      0,
+      0
+    )
+
+    if handle == INVALID_HANDLE_VALUE
+      raise SystemCallError.new("CreateFile", FFI.errno)
+    end
+
+    begin
+      bool = DeviceIoControl(
+        handle,
+        FSCTL_SET_COMPRESSION(),
+        in_buf,
+        in_buf.size,
+        nil,
+        0,
+        bytes,
+        nil
+      )
+
+      unless bool
+        raise SystemCallError.new("DeviceIoControl", FFI.errno)
+      end
+    ensure
+      CloseHandle(handle)
+    end
+
+    self
+  end
+
+  # Sets the hidden attribute to true or false.  Setting this attribute to
+  # true means that the file is not included in an ordinary directory listing.
+  #
+  def hidden=(bool)
+    wide_path  = self.path.wincode
+    attributes = GetFileAttributesW(wide_path)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    if bool
+      attributes |= FILE_ATTRIBUTE_HIDDEN;
+    else
+      attributes &= ~FILE_ATTRIBUTE_HIDDEN;
+    end
+
+    if SetFileAttributesW(wide_path, attributes) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  # Sets the 'indexed' attribute to true or false.  Setting this to
+  # false means that the file will not be indexed by the content indexing
+  # service.
+  #
+  def indexed=(bool)
+    wide_path  = self.path.wincode
+    attributes = GetFileAttributesW(wide_path)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    if bool
+      attributes &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+    else
+      attributes |= FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+    end
+
+    if SetFileAttributesW(wide_path, attributes) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  alias :content_indexed= :indexed=
+
+  # Sets the normal attribute. Note that only 'true' is a valid argument,
+  # which has the effect of removing most other attributes.  Attempting to
+  # pass any value except true will raise an ArgumentError.
+  #
+  def normal=(bool)
+    unless bool
+      raise ArgumentError, "only 'true' may be passed as an argument"
+    end
+
+    if SetFileAttributesW(self.path.wincode, FILE_ATTRIBUTE_NORMAL) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  # Sets whether or not a file is online or not.  Setting this to false means
+	# that the data of the file is not immediately available. This attribute
+	# indicates that the file data has been physically moved to offline storage.
+	# This attribute is used by Remote Storage, the hierarchical storage
+	# management software.
+  #
+	# Applications should not arbitrarily change this attribute.
+  #
+  def offline=(bool)
+    wide_path  = self.path.wincode
+    attributes = GetFileAttributesW(wide_path)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    if bool
+      attributes |= FILE_ATTRIBUTE_OFFLINE;
+    else
+      attributes &= ~FILE_ATTRIBUTE_OFFLINE;
+    end
+
+    if SetFileAttributesW(wide_path, attributes) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  # Sets the readonly attribute.  If set to true the the file or directory is
+  # readonly. Applications can read the file but cannot write to it or delete
+  # it. In the case of a directory, applications cannot delete it.
+  #
+  def readonly=(bool)
+    wide_path  = self.path.wincode
+    attributes = GetFileAttributesW(wide_path)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    if bool
+      attributes |= FILE_ATTRIBUTE_READONLY;
+    else
+      attributes &= ~FILE_ATTRIBUTE_READONLY;
+    end
+
+    if SetFileAttributesW(wide_path, attributes) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  # Sets the file to a sparse (usually image) file.  Note that you cannot
+  # remove the sparse property from a file.
+  #
+  def sparse=(bool)
+    unless bool
+      warn 'cannot remove sparse property from a file - operation ignored'
+      return
+    end
+
+    bytes = FFI::MemoryPointer.new(:ulong)
+
+    handle = CreateFileW(
+      self.path.wincode,
+      FILE_READ_DATA | FILE_WRITE_DATA,
+      FILE_SHARE_READ | FILE_SHARE_WRITE,
+      0,
+      OPEN_EXISTING,
+      FSCTL_SET_SPARSE(),
+      0
+    )
+
+    if handle == INVALID_HANDLE_VALUE
+      raise SystemCallError.new("CreateFile", FFI.errno)
+    end
+
+    begin
+      bool = DeviceIoControl(
+        handle,
+        FSCTL_SET_SPARSE(),
+        nil,
+        0,
+        nil,
+        0,
+        bytes,
+        nil
+      )
+
+      unless bool == 0
+        raise SystemCallError.new("DeviceIoControl", FFI.errno)
+      end
+    ensure
+      CloseHandle(handle)
+    end
+
+    self
+  end
+
+  # Set whether or not the file is a system file.  A system file is a file
+	# that is part of the operating system or is used exclusively by it.
+  #
+  def system=(bool)
+    wide_path  = self.path.wincode
+    attributes = GetFileAttributesW(wide_path)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    if bool
+      attributes |= FILE_ATTRIBUTE_SYSTEM;
+    else
+      attributes &= ~FILE_ATTRIBUTE_SYSTEM;
+    end
+
+    if SetFileAttributesW(wide_path, attributes) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  # Sets whether or not the file is being used for temporary storage.
+  #
+  # File systems avoid writing data back to mass storage if sufficient cache
+  # memory is available, because often the application deletes the temporary
+  # file shortly after the handle is closed. In that case, the system can
+  # entirely avoid writing the data. Otherwise, the data will be written
+  # after the handle is closed.
+  #
+  def temporary=(bool)
+    wide_path  = self.path.wincode
+    attributes = GetFileAttributesW(wide_path)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    if bool
+      attributes |= FILE_ATTRIBUTE_TEMPORARY;
+    else
+      attributes &= ~FILE_ATTRIBUTE_TEMPORARY;
+    end
+
+    if SetFileAttributesW(wide_path, attributes) == 0
+      raise SystemCallError.new("SetFileAttributes", FFI.errno)
+    end
+
+    self
+  end
+
+  private
+
+  # Convenience method used internally for the various boolean singleton methods.
+  #
+  def self.check_for_attribute(file, attribute)
+    attributes = GetFileAttributesW(file.wincode)
+
+    if attributes == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new("GetFileAttributes", FFI.errno)
+    end
+
+    attributes & attribute > 0 ? true : false
+  end
+end

data/lib/win32/file/windows/constants.rb

@@ -0,0 +1,33 @@
+module Windows
+  module File
+    module Constants
+      FILE_ATTRIBUTE_READONLY      = 0x00000001
+      FILE_ATTRIBUTE_HIDDEN        = 0x00000002
+      FILE_ATTRIBUTE_SYSTEM        = 0x00000004
+      FILE_ATTRIBUTE_DIRECTORY     = 0x00000010
+      FILE_ATTRIBUTE_ARCHIVE       = 0x00000020
+      FILE_ATTRIBUTE_ENCRYPTED     = 0x00000040
+      FILE_ATTRIBUTE_NORMAL        = 0x00000080
+      FILE_ATTRIBUTE_TEMPORARY     = 0x00000100
+      FILE_ATTRIBUTE_SPARSE_FILE   = 0x00000200
+      FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400
+      FILE_ATTRIBUTE_COMPRESSED    = 0x00000800
+      FILE_ATTRIBUTE_OFFLINE       = 0x00001000
+
+      FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x00002000
+
+      COMPRESSION_FORMAT_NONE    = 0
+      COMPRESSION_FORMAT_DEFAULT = 1
+
+      INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF
+      INVALID_HANDLE_VALUE    = 0xFFFFFFFF
+
+      FILE_READ_DATA   = 1
+      FILE_WRITE_DATA  = 2
+      FILE_SHARE_READ  = 1
+      FILE_SHARE_WRITE = 2
+
+      OPEN_EXISTING = 3
+    end
+  end
+end

data/lib/win32/file/windows/functions.rb

@@ -0,0 +1,36 @@
+require 'ffi'
+
+module Windows
+  module File
+    module Functions
+      extend FFI::Library
+      ffi_lib :kernel32
+
+      attach_function :CloseHandle, [:ulong], :bool
+      attach_function :CreateFileW, [:buffer_in, :ulong, :ulong, :pointer, :ulong, :ulong, :ulong], :ulong
+      attach_function :DeviceIoControl, [:ulong, :ulong, :pointer, :ulong, :pointer, :ulong, :pointer, :pointer], :bool
+      attach_function :GetFileAttributesW, [:buffer_in], :ulong
+      attach_function :SetFileAttributesW, [:buffer_in, :ulong], :ulong
+
+      def CTL_CODE(device, function, method, access)
+         ((device) << 16) | ((access) << 14) | ((function) << 2) | (method)
+      end
+
+      def FSCTL_SET_COMPRESSION
+         CTL_CODE(9, 16, 0, 3)
+      end
+
+      def FSCTL_SET_SPARSE
+         CTL_CODE(9, 49, 0, 0)
+      end
+    end
+  end
+end
+
+class String
+  # Convenience method for converting strings to UTF-16LE for wide character
+  # functions that require it.
+  def wincode
+    (self.tr(File::SEPARATOR, File::ALT_SEPARATOR) + 0.chr).encode('UTF-16LE')
+  end
+end

data/lib/win32/file/windows/structs.rb

@@ -0,0 +1,6 @@
+module Windows
+  module File
+    module Structs
+    end
+  end
+end

data/test/test_win32_file_attributes.rb

@@ -0,0 +1,376 @@
+#############################################################################
+# test_win32_file_attributes.rb
+#
+# Test case for the attribute related methods of win32-file. You should run
+# this via the 'rake test' or 'rake test_attributes' task.
+#############################################################################
+require 'ffi'
+require 'test-unit'
+require 'win32/file/attributes'
+
+class TC_Win32_File_Attributes < Test::Unit::TestCase
+  extend FFI::Library
+  ffi_lib :kernel32
+
+  attach_function :GetFileAttributes, :GetFileAttributesA, [:string], :ulong
+  attach_function :SetFileAttributes, :SetFileAttributesA, [:string, :ulong], :ulong
+
+  def self.startup
+    Dir.chdir(File.dirname(File.expand_path(File.basename(__FILE__))))
+    @@file = File.join(Dir.pwd, 'test_file.txt')
+    File.open(@@file, 'w'){ |fh| fh.puts "This is a test." }
+  end
+
+  def setup
+    @fh   = File.open(@@file)
+    @attr = GetFileAttributes(@@file)
+  end
+
+  test "version is set to expected value" do
+    assert_equal('1.0.0', File::WIN32_FILE_ATTRIBUTE_VERSION)
+  end
+
+  test "temporary? singleton method basic functionality" do
+    assert_respond_to(File, :temporary?)
+    assert_nothing_raised{ File.temporary?(@@file) }
+  end
+
+  test "temporary? singleton method returns expected value" do
+    assert_false(File.temporary?(@@file))
+  end
+
+  test "temporary? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.temporary? }
+    assert_raises(ArgumentError){ File.temporary?(@@file, 'foo') }
+  end
+
+  test "temporary? instance method basic functionality" do
+    assert_respond_to(@fh, :temporary=)
+    assert_nothing_raised{ @fh.temporary = true }
+  end
+
+  test "temporary? instance method works as expected" do
+    assert_false(File.temporary?(@@file))
+    @fh.temporary = true
+    assert_true(File.temporary?(@@file))
+  end
+
+  test "system? singleton method basic functionality" do
+    assert_respond_to(File, :system?)
+    assert_nothing_raised{ File.system?(@@file) }
+  end
+
+  test "system? singleton method returns the expected value" do
+    assert_false(File.system?(@@file))
+  end
+
+  test "system singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.system? }
+    assert_raises(ArgumentError){ File.system?(@@file, 'foo') }
+  end
+
+  test "system instance method basic functionality" do
+    assert_respond_to(@fh, :system=)
+    assert_nothing_raised{ @fh.system = true }
+  end
+
+  test "system instance method works as expected" do
+    assert_false(File.system?(@@file))
+    @fh.system = true
+    assert_true(File.system?(@@file))
+  end
+
+  test "sparse? singleton method basic functionality" do
+    assert_respond_to(File, :sparse?)
+    assert_nothing_raised{ File.sparse?(@@file) }
+  end
+
+  test "sparse? singleton method returns expected value" do
+    assert_false(File.sparse?(@@file))
+  end
+
+  test "sparse? singleton method requires one argument" do
+    assert_raises(ArgumentError){ File.sparse? }
+    assert_raises(ArgumentError){ File.sparse?(@@file, 'foo') }
+  end
+
+  # I don't actually test true assignment here since making a file a
+  # sparse file can't be undone.
+  test "sparse? instance method basic functionality" do
+    assert_respond_to(@fh, :sparse=)
+    assert_nothing_raised{ @fh.sparse= false }
+  end
+
+  test "reparse_point? singleton method basic functionality" do
+    assert_respond_to(File, :reparse_point?)
+    assert_nothing_raised{ File.reparse_point?(@@file) }
+  end
+
+  test "reparse_point? singleton method returns the expected value" do
+    assert_false(File.reparse_point?(@@file))
+  end
+
+  test "reparse_point? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.reparse_point? }
+    assert_raises(ArgumentError){ File.reparse_point?(@@file, 'foo') }
+  end
+
+  test "readonly? singleton method basic functionality" do
+    assert_respond_to(File, :readonly?)
+    assert_nothing_raised{ File.readonly?(@@file) }
+  end
+
+  test "readonly? singleton method returns expected result" do
+    assert_false(File.readonly?(@@file))
+  end
+
+  test "readonly? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.read_only? }
+    assert_raises(ArgumentError){ File.read_only?(@@file, 'foo') }
+  end
+
+  test "read_only? is an alias for readonly?" do
+    assert_respond_to(File, :read_only?)
+    assert_alias_method(File, :read_only?, :readonly?)
+  end
+
+  test "readonly? instance method basic functionality" do
+    assert_respond_to(@fh, :readonly=)
+    assert_nothing_raised{ @fh.readonly = true }
+  end
+
+  test "readonly? instance method returns expected value" do
+    assert_false(File.readonly?(@@file))
+    @fh.readonly = true
+    assert_true(File.readonly?(@@file))
+  end
+
+  test "offline? singleton method basic functionality" do
+    assert_respond_to(File, :offline?)
+    assert_nothing_raised{ File.offline?(@@file) }
+  end
+
+  test "offline? singleton method returns expected result" do
+    assert_false(File.offline?(@@file))
+  end
+
+  test "offline? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.offline? }
+    assert_raises(ArgumentError){ File.offline?(@@file, 'foo') }
+  end
+
+  test "offline? instance method basic functionality" do
+    assert_respond_to(@fh, :offline=)
+    assert_nothing_raised{ @fh.offline =  true }
+  end
+
+  test "offline? instance method returns expected value" do
+    assert_false(File.offline?(@@file))
+    @fh.offline = true
+    assert_true(File.offline?(@@file))
+  end
+
+  test "normal? singleton method basic functionality" do
+    assert_respond_to(File, :normal?)
+    assert_nothing_raised{ File.normal?(@@file) }
+  end
+
+  test "normal? singleton method returns expected results" do
+    assert_false(File.normal?(@@file))
+    @fh.normal = true
+    assert_true(File.normal?(@@file))
+  end
+
+  test "normal? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.normal? }
+    assert_raises(ArgumentError){ File.normal?(@@file, 'foo') }
+  end
+
+  test "normal? instance method basic functionality" do
+    assert_respond_to(@fh, :normal=)
+    assert_nothing_raised{ @fh.normal = true }
+  end
+
+  test "normal? instance method setter does not accept false" do
+    assert_raises(ArgumentError){ @fh.normal = false }
+  end
+
+  test "hidden? singleton method basic functionality" do
+    assert_respond_to(File, :hidden?)
+    assert_nothing_raised{ File.hidden?(@@file) }
+  end
+
+  test "hidden? singleton method returns the expected result" do
+    assert_false(File.hidden?(@@file))
+    @fh.hidden = true
+    assert_true(File.hidden?(@@file))
+  end
+
+  test "hidden? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.hidden? }
+    assert_raises(ArgumentError){ File.hidden?(@@file, 'foo') }
+  end
+
+  test "hidden? instance method basic functionality" do
+    assert_respond_to(@fh, :hidden=)
+    assert_nothing_raised{ @fh.hidden = true }
+  end
+
+  test "encrypted? singleton method basic functionality" do
+    assert_respond_to(File, :encrypted?)
+    assert_nothing_raised{ File.encrypted?(@@file) }
+  end
+
+  test "encrypted? singleton method returns the expected result" do
+    assert_false(File.encrypted?(@@file))
+  end
+
+  test "encrypted? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.encrypted? }
+    assert_raises(ArgumentError){ File.encrypted?(@@file, 'foo') }
+  end
+
+  test "indexed? singleton method basic functionality" do
+    assert_respond_to(File, :indexed?)
+    assert_nothing_raised{ File.indexed?(@@file) }
+  end
+
+  test "indexed? singleton method returns the expected results" do
+    assert_true(File.indexed?(@@file))
+    @fh.indexed = false
+    assert_false(File.indexed?(@@file))
+  end
+
+  test "content_indexed? is an alias for indexed?" do
+    assert_respond_to(File, :content_indexed?)
+    assert_alias_method(File, :content_indexed?, :indexed?)
+  end
+
+  test "indexed? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.indexed? }
+    assert_raises(ArgumentError){ File.indexed?(@@file, 'foo') }
+  end
+
+  test "indexed? instance method basic functionality" do
+    assert_respond_to(@fh, :indexed=)
+    assert_nothing_raised{ @fh.indexed = true }
+  end
+
+  test "indexed? instance method returns expected method" do
+    assert_true(File.indexed?(@@file))
+    @fh.indexed = false
+    assert_false(File.indexed?(@@file))
+  end
+
+  test "compressed? singleton method basic functionality" do
+    assert_respond_to(File, :compressed?)
+    assert_nothing_raised{ File.compressed?(@@file) }
+  end
+
+  test "compressed? singleton method returns the expected result" do
+    assert_false(File.compressed?(@@file))
+  end
+
+  test "compressed instance method setter basic functionality" do
+    assert_respond_to(@fh, :compressed=)
+    assert_false(File.compressed?(@@file))
+  end
+
+  test "compressed? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.compressed? }
+    assert_raises(ArgumentError){ File.compressed?(@@file, 'foo') }
+  end
+
+  # We have to explicitly reset the compressed attribute to false as
+  # the last of these assertions.
+
+  test "compressed instance method setter works as expected" do
+    assert_nothing_raised{ @fh.compressed = true }
+    assert_true(File.compressed?(@@file))
+    assert_nothing_raised{ @fh.compressed = false }
+    assert_false(File.compressed?(@@file))
+  end
+
+  test "archive? singleton method basic functionality" do
+    assert_respond_to(File, :archive?)
+    assert_nothing_raised{ File.archive?(@@file) }
+  end
+
+  test "archive? singleton method returns the expected results" do
+    assert_true(File.archive?(@@file))
+    @fh.archive = false
+    assert_false(File.archive?(@@file))
+  end
+
+  test "archive? singleton method requires a single argument" do
+    assert_raises(ArgumentError){ File.archive? }
+    assert_raises(ArgumentError){ File.archive?(@@file, 'foo') }
+  end
+
+  test "archive instance method setter basic functionality" do
+    assert_respond_to(@fh, :archive=)
+    assert_nothing_raised{ @fh.archive = false }
+  end
+
+  test "attributes singleton method basic functionality" do
+    assert_respond_to(File, :attributes)
+    assert_kind_of(Array, File.attributes(@@file))
+  end
+
+  test "attributes singleton method returns expected results" do
+    assert_equal(['archive', 'indexed'], File.attributes(@@file))
+  end
+
+  test "set_attributes singleton method basic functionality" do
+    assert_respond_to(File, :set_attributes)
+    assert_nothing_raised{ File.set_attributes(@@file, File::FILE_ATTRIBUTE_HIDDEN) }
+  end
+
+  test "set_attributes singleton method works as expected" do
+    assert_nothing_raised{ File.set_attributes(@@file, File::FILE_ATTRIBUTE_HIDDEN) }
+    assert_true(File.attributes(@@file).include?('hidden'))
+  end
+
+  test "set_attr is an alias for set_attributes" do
+    assert_respond_to(File, :set_attr)
+    assert_alias_method(File, :set_attr, :set_attributes)
+  end
+
+  test "remove_attributes singleton method basic functionality" do
+    assert_respond_to(File, :remove_attributes)
+    assert_nothing_raised{ File.remove_attributes(@@file, File::FILE_ATTRIBUTE_ARCHIVE) }
+  end
+
+  test "remove_attributes works as expected" do
+    assert_true(File.archive?(@@file))
+    assert_nothing_raised{ File.remove_attributes(@@file, File::FILE_ATTRIBUTE_ARCHIVE) }
+    assert_false(File.archive?(@@file))
+  end
+
+  test "unset_attr is an alias for remove_attributes" do
+    assert_respond_to(File, :unset_attr)
+    assert_alias_method(File, :unset_attr, :remove_attributes)
+  end
+
+  test "shorthand constants are defined" do
+    assert_not_nil(File::ARCHIVE)
+    assert_not_nil(File::HIDDEN)
+    assert_not_nil(File::NORMAL)
+    assert_not_nil(File::INDEXED)
+    assert_not_nil(File::OFFLINE)
+    assert_not_nil(File::READONLY)
+    assert_not_nil(File::SYSTEM)
+    assert_not_nil(File::TEMPORARY)
+    assert_not_nil(File::CONTENT_INDEXED) # alias for INDEXED
+  end
+
+  def teardown
+    SetFileAttributes(@@file, @attr)
+    @fh.close
+  end
+
+  def self.shutdown
+    File.delete(@@file)
+    @@file = nil
+  end
+end

data/win32-file-attributes.gemspec

@@ -0,0 +1,24 @@
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'win32-file-attributes'
+  spec.version    = '1.0.0'
+  spec.authors    = ['Daniel J. Berger', 'Park Heesob']
+  spec.license    = 'Artistic 2.0'
+  spec.email      = 'djberg96@gmail.com'
+  spec.homepage   = 'http://github.com/djberg96/win32-file-attributes'
+  spec.summary    = 'File attribute methods for the File class on MS Windows'
+  spec.test_files = Dir['test/test*']
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+
+  spec.rubyforge_project = 'win32utils'
+  spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
+
+  spec.add_dependency('ffi')
+  spec.add_development_dependency('test-unit')
+
+  spec.description = <<-EOF
+    The win32-file-attribute library adds several file attribute methods to
+    the core File class which are specific to MS Windows.
+  EOF
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: win32-file-attributes
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Daniel J. Berger
+- Park Heesob
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "    The win32-file-attribute library adds several file attribute methods
+  to\n    the core File class which are specific to MS Windows.\n"
+email: djberg96@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+- CHANGES
+- MANIFEST
+files:
+- CHANGES
+- lib/win32/file/attributes.rb
+- lib/win32/file/windows/constants.rb
+- lib/win32/file/windows/functions.rb
+- lib/win32/file/windows/structs.rb
+- MANIFEST
+- Rakefile
+- README
+- test/test_win32_file_attributes.rb
+- win32-file-attributes.gemspec
+homepage: http://github.com/djberg96/win32-file-attributes
+licenses:
+- Artistic 2.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: win32utils
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: File attribute methods for the File class on MS Windows
+test_files:
+- test/test_win32_file_attributes.rb