win32ole 1.8.8 → 1.8.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfff5b9994fea1fd3249f3d80aa265a21cd27f7ddd8d74bc34438f987342f97b
-  data.tar.gz: cd3953182a81a6bb9bbc5d561bdc800aee603cccda736113cd37785685564bb2
+  metadata.gz: eeded5c3c12c689465044f51fcb85120250656bdccd82aed9f361bd49dac58d8
+  data.tar.gz: 3544f2afa9b6843d31e44dacc08d9d867751c207389df0d50acb0d1e797b1c01
 SHA512:
-  metadata.gz: 984fbc6c59a16d9855982896c1fa1230ec6a68ee90083afe7564fce2e07a8e8c05131dfbc322175858be520da1b109ddc642a262bee7c4bcbad809aaaca01b30
-  data.tar.gz: a88c069fe37638ffa0749fc113506b96d23c0882e0953c4d4d55583111fc3012c18941b9989500c2645e564cb238f7dd85b35363fbdbf85e8296f94b9c813738
+  metadata.gz: ce52dc4fd54fd403a2bc56b50caab5740b669b44268de725168abf8f0793923056f0eac6542535d085dbc3175edc97c0aeb9d817d37b6cfabd1a61efa98689f1
+  data.tar.gz: eeff5a7db020796fee5b4e3e699e1b1f777f02af072424b1c7ddeb6aa4bfcb566494efac194a10a10a1ea026070862586fd764ae7c51ae5f6eb9f8bbbf6bbd65

data/.git-blame-ignore-revs

@@ -0,0 +1,7 @@
+# This is a file used by GitHub to ignore the following commits on `git blame`.
+#
+# You can also do the same thing in your local repository with:
+# $ git config --local blame.ignoreRevsFile .git-blame-ignore-revs
+
+# Expand tabs
+0667bd63edb6bffeaa59f7ebc3dbe42b82ac496d

data/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'

data/.github/workflows/windows.yml

@@ -0,0 +1,30 @@
+name: windows
+
+on: [push, pull_request]
+
+jobs:
+  ruby-versions:
+    uses: ruby/actions/.github/workflows/ruby_versions.yml@master
+    with:
+      engine: cruby
+      min_version: 2.6
+      versions: '["mswin", "mingw"]'
+
+  test:
+    needs: ruby-versions
+    name: build (${{ matrix.ruby }})
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ${{ fromJson(needs.ruby-versions.outputs.versions) }}
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run test
+      run: bundle exec rake
+

data/Gemfile

@@ -3,5 +3,6 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in win32ole.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
-gem "minitest", "~> 5.0"
+gem 'rake-compiler'
+gem 'test-unit'
+gem "test-unit-ruby-core"

data/Rakefile

@@ -1,10 +1,19 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
+name = "win32ole"
+
+require 'rake/extensiontask'
+extask = Rake::ExtensionTask.new(name) do |x|
+  x.lib_dir << "/#{RUBY_VERSION}/#{x.platform}"
+end
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
+  t.libs << extask.lib_dir
+  t.libs << "test/lib"
   t.libs << "lib"
+  t.ruby_opts << "-rhelper"
   t.test_files = FileList["test/**/test_*.rb"]
 end
 
 task :default => :test
+task :test => :compile

data/ext/win32ole/sample/xml.rb

@@ -1032,8 +1032,8 @@ module IXMLDOMDocument
   end
 
   # VOID save
-  # save the document to a specified desination
-  #   VARIANT arg0 --- desination [IN]
+  # save the document to a specified destination
+  #   VARIANT arg0 --- destination [IN]
   def save(arg0)
     ret = _invoke(64, [arg0], [VT_VARIANT])
     @lastargs = WIN32OLE::ARGV
@@ -6224,8 +6224,8 @@ class Microsoft_XMLDOM_1_0 # DOMDocument
   end
 
   # VOID save
-  # save the document to a specified desination
-  #   VARIANT arg0 --- desination [IN]
+  # save the document to a specified destination
+  #   VARIANT arg0 --- destination [IN]
   def save(arg0)
     ret = @dispatch._invoke(64, [arg0], [VT_VARIANT])
     @lastargs = WIN32OLE::ARGV
@@ -6831,8 +6831,8 @@ class Microsoft_FreeThreadedXMLDOM_1_0 # DOMFreeThreadedDocument
   end
 
   # VOID save
-  # save the document to a specified desination
-  #   VARIANT arg0 --- desination [IN]
+  # save the document to a specified destination
+  #   VARIANT arg0 --- destination [IN]
   def save(arg0)
     ret = @dispatch._invoke(64, [arg0], [VT_VARIANT])
     @lastargs = WIN32OLE::ARGV

data/ext/win32ole/win32ole.c

@@ -27,7 +27,7 @@
 const IID IID_IMultiLanguage2 = {0xDCCFC164, 0x2B38, 0x11d2, {0xB7, 0xEC, 0x00, 0xC0, 0x4F, 0x8F, 0x5D, 0x9A}};
 #endif
 
-#define WIN32OLE_VERSION "1.8.8"
+#define WIN32OLE_VERSION "1.8.10"
 
 typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
     (REFCLSID, IUnknown*, DWORD, COSERVERINFO*, DWORD, MULTI_QI*);
@@ -454,12 +454,12 @@ vtdate2rbtime(double date)
     double sec;
     VariantTimeToSystemTime(date, &st);
     v = rb_funcall(rb_cTime, rb_intern("new"), 6,
-		      RB_INT2FIX(st.wYear),
-		      RB_INT2FIX(st.wMonth),
-		      RB_INT2FIX(st.wDay),
-		      RB_INT2FIX(st.wHour),
-		      RB_INT2FIX(st.wMinute),
-		      RB_INT2FIX(st.wSecond));
+                      RB_INT2FIX(st.wYear),
+                      RB_INT2FIX(st.wMonth),
+                      RB_INT2FIX(st.wDay),
+                      RB_INT2FIX(st.wHour),
+                      RB_INT2FIX(st.wMinute),
+                      RB_INT2FIX(st.wSecond));
     st.wYear = RB_FIX2INT(rb_funcall(v, rb_intern("year"), 0));
     st.wMonth = RB_FIX2INT(rb_funcall(v, rb_intern("month"), 0));
     st.wDay = RB_FIX2INT(rb_funcall(v, rb_intern("mday"), 0));
@@ -507,6 +507,7 @@ static UINT ole_encoding2cp(rb_encoding *enc)
     ENC_MACHING_CP(enc, "GB2312", 20936);
     ENC_MACHING_CP(enc, "GBK", 936);
     ENC_MACHING_CP(enc, "IBM437", 437);
+    ENC_MACHING_CP(enc, "IBM720", 720);
     ENC_MACHING_CP(enc, "IBM737", 737);
     ENC_MACHING_CP(enc, "IBM775", 775);
     ENC_MACHING_CP(enc, "IBM852", 852);
@@ -567,16 +568,16 @@ load_conv_function51932(void)
     void *p;
     if (!pIMultiLanguage) {
 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
-	hr = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
-		              &IID_IMultiLanguage2, &p);
+        hr = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
+                              &IID_IMultiLanguage2, &p);
 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
-	hr = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
-		              &IID_IMultiLanguage, &p);
+        hr = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
+                              &IID_IMultiLanguage, &p);
 #endif
-	if (FAILED(hr)) {
-	    failed_load_conv51932();
-	}
-	pIMultiLanguage = p;
+        if (FAILED(hr)) {
+            failed_load_conv51932();
+        }
+        pIMultiLanguage = p;
     }
 }
 #define need_conv_function51932() (load_conv_function51932(), 1)
@@ -623,7 +624,7 @@ ole_init_cp(void)
     rb_encoding *encdef;
     encdef = rb_default_internal_encoding();
     if (!encdef) {
-	encdef = rb_default_external_encoding();
+        encdef = rb_default_external_encoding();
     }
     cp = ole_encoding2cp(encdef);
     set_ole_codepage(cp);
@@ -649,38 +650,38 @@ ole_cp2encoding(UINT cp)
     int idx;
 
     if (!code_page_installed(cp)) {
-	switch(cp) {
-	  case CP_ACP:
-	    cp = GetACP();
-	    break;
-	  case CP_OEMCP:
-	    cp = GetOEMCP();
-	    break;
-	  case CP_MACCP:
-	  case CP_THREAD_ACP:
-	    if (!pGetCPInfoEx) {
-		pGetCPInfoEx = (BOOL (*)(UINT, DWORD, struct myCPINFOEX *))
-		    GetProcAddress(GetModuleHandle("kernel32"), "GetCPInfoEx");
-		if (!pGetCPInfoEx) {
-		    pGetCPInfoEx = (void*)-1;
-		}
-	    }
-	    buf = ALLOCA_N(struct myCPINFOEX, 1);
-	    ZeroMemory(buf, sizeof(struct myCPINFOEX));
-	    if (pGetCPInfoEx == (void*)-1 || !pGetCPInfoEx(cp, 0, buf)) {
-		rb_raise(eWIN32OLERuntimeError, "cannot map codepage to encoding.");
-		break;	/* never reach here */
-	    }
-	    cp = buf->CodePage;
-	    break;
-	  case CP_SYMBOL:
-	  case CP_UTF7:
-	  case CP_UTF8:
-	    break;
-	  case 51932:
-	    load_conv_function51932();
-	    break;
-	  default:
+        switch(cp) {
+          case CP_ACP:
+            cp = GetACP();
+            break;
+          case CP_OEMCP:
+            cp = GetOEMCP();
+            break;
+          case CP_MACCP:
+          case CP_THREAD_ACP:
+            if (!pGetCPInfoEx) {
+                pGetCPInfoEx = (BOOL (*)(UINT, DWORD, struct myCPINFOEX *))
+                    GetProcAddress(GetModuleHandle("kernel32"), "GetCPInfoEx");
+                if (!pGetCPInfoEx) {
+                    pGetCPInfoEx = (void*)-1;
+                }
+            }
+            buf = ALLOCA_N(struct myCPINFOEX, 1);
+            ZeroMemory(buf, sizeof(struct myCPINFOEX));
+            if (pGetCPInfoEx == (void*)-1 || !pGetCPInfoEx(cp, 0, buf)) {
+                rb_raise(eWIN32OLERuntimeError, "cannot map codepage to encoding.");
+                break;	/* never reach here */
+            }
+            cp = buf->CodePage;
+            break;
+          case CP_SYMBOL:
+          case CP_UTF7:
+          case CP_UTF8:
+            break;
+          case 51932:
+            load_conv_function51932();
+            break;
+          default:
             rb_raise(eWIN32OLERuntimeError, "codepage should be WIN32OLE::CP_ACP, WIN32OLE::CP_OEMCP, WIN32OLE::CP_MACCP, WIN32OLE::CP_THREAD_ACP, WIN32OLE::CP_SYMBOL, WIN32OLE::CP_UTF7, WIN32OLE::CP_UTF8, or installed codepage.");
             break;
         }
@@ -689,7 +690,7 @@ ole_cp2encoding(UINT cp)
     enc_name = rb_sprintf("CP%d", cp);
     idx = rb_enc_find_index(enc_cstr = StringValueCStr(enc_name));
     if (idx < 0)
-	idx = rb_define_dummy_encoding(enc_cstr);
+        idx = rb_define_dummy_encoding(enc_cstr);
     return rb_enc_from_index(idx);
 }
 
@@ -699,14 +700,14 @@ ole_ml_wc2mb_conv0(LPWSTR pw, LPSTR pm, UINT *size)
 {
     DWORD dw = 0;
     return pIMultiLanguage->lpVtbl->ConvertStringFromUnicode(pIMultiLanguage,
-		    &dw, cWIN32OLE_cp, pw, NULL, pm, size);
+                    &dw, cWIN32OLE_cp, pw, NULL, pm, size);
 }
 #define ole_ml_wc2mb_conv(pw, pm, size, onfailure) do { \
-	HRESULT hr = ole_ml_wc2mb_conv0(pw, pm, &size); \
-	if (FAILED(hr)) { \
-	    onfailure; \
-	    ole_raise(hr, eWIN32OLERuntimeError, "fail to convert Unicode to CP%d", cWIN32OLE_cp); \
-	} \
+        HRESULT hr = ole_ml_wc2mb_conv0(pw, pm, &size); \
+        if (FAILED(hr)) { \
+            onfailure; \
+            ole_raise(hr, eWIN32OLERuntimeError, "fail to convert Unicode to CP%d", cWIN32OLE_cp); \
+        } \
     } while (0)
 #endif
 
@@ -719,11 +720,11 @@ ole_wc2mb_alloc(LPWSTR pw, char *(alloc)(UINT size, void *arg), void *arg)
     UINT size = 0;
     if (conv_51932(cWIN32OLE_cp)) {
 #ifndef pIMultiLanguage
-	ole_ml_wc2mb_conv(pw, NULL, size, {});
-	pm = alloc(size, arg);
-	if (size) ole_ml_wc2mb_conv(pw, pm, size, xfree(pm));
-	pm[size] = '\0';
-	return pm;
+        ole_ml_wc2mb_conv(pw, NULL, size, {});
+        pm = alloc(size, arg);
+        if (size) ole_ml_wc2mb_conv(pw, pm, size, xfree(pm));
+        pm[size] = '\0';
+        return pm;
 #endif
     }
     size = ole_wc2mb_conv(pw, NULL, 0);
@@ -815,8 +816,8 @@ ole_initialize(void)
     HRESULT hr;
 
     if(!g_uninitialize_hooked) {
-	rb_add_event_hook(ole_uninitialize_hook, RUBY_EVENT_THREAD_END, Qnil);
-	g_uninitialize_hooked = TRUE;
+        rb_add_event_hook(ole_uninitialize_hook, RUBY_EVENT_THREAD_END, Qnil);
+        g_uninitialize_hooked = TRUE;
     }
 
     if(g_ole_initialized == FALSE) {
@@ -910,21 +911,21 @@ ole_mb2wc(char *pm, int len, UINT cp)
 
     if (conv_51932(cp)) {
 #ifndef pIMultiLanguage
-	DWORD dw = 0;
-	UINT n = len;
-	HRESULT hr = pIMultiLanguage->lpVtbl->ConvertStringToUnicode(pIMultiLanguage,
-		&dw, cp, pm, &n, NULL, &size);
-	if (FAILED(hr)) {
+        DWORD dw = 0;
+        UINT n = len;
+        HRESULT hr = pIMultiLanguage->lpVtbl->ConvertStringToUnicode(pIMultiLanguage,
+                &dw, cp, pm, &n, NULL, &size);
+        if (FAILED(hr)) {
             ole_raise(hr, eWIN32OLERuntimeError, "fail to convert CP%d to Unicode", cp);
-	}
-	pw = SysAllocStringLen(NULL, size);
-	n = len;
-	hr = pIMultiLanguage->lpVtbl->ConvertStringToUnicode(pIMultiLanguage,
-		&dw, cp, pm, &n, pw, &size);
-	if (FAILED(hr)) {
+        }
+        pw = SysAllocStringLen(NULL, size);
+        n = len;
+        hr = pIMultiLanguage->lpVtbl->ConvertStringToUnicode(pIMultiLanguage,
+                &dw, cp, pm, &n, pw, &size);
+        if (FAILED(hr)) {
             ole_raise(hr, eWIN32OLERuntimeError, "fail to convert CP%d to Unicode", cp);
-	}
-	return pw;
+        }
+        return pw;
 #endif
     }
     size = MultiByteToWideChar(cp, 0, pm, len, NULL, 0);
@@ -994,7 +995,7 @@ ole_val2variant_ex(VALUE val, VARIANT *var, VARTYPE vt)
         }
         return;
     }
-#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__)
     switch(vt & ~VT_BYREF) {
     case VT_I8:
         V_VT(var) = VT_I8;
@@ -1008,7 +1009,7 @@ ole_val2variant_ex(VALUE val, VARIANT *var, VARTYPE vt)
         ole_val2variant2(val, var);
         break;
     }
-#else  /* (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) */
+#else  /* (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__) */
     ole_val2variant2(val, var);
 #endif
 }
@@ -1062,7 +1063,7 @@ get_ptr_of_variant(VARIANT *pvar)
     case VT_R8:
         return &V_R8(pvar);
         break;
-#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__)
     case VT_I8:
         return &V_I8(pvar);
         break;
@@ -1549,10 +1550,10 @@ ole_variant2val(VARIANT *pvar)
             obj = RB_INT2NUM((long)V_UINT(pvar));
         break;
 
-#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__)
     case VT_I8:
         if(V_ISBYREF(pvar))
-#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__)
 #ifdef V_I8REF
             obj = I8_2_NUM(*V_I8REF(pvar));
 #endif
@@ -1564,7 +1565,7 @@ ole_variant2val(VARIANT *pvar)
         break;
     case VT_UI8:
         if(V_ISBYREF(pvar))
-#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__)
 #ifdef V_UI8REF
             obj = UI8_2_NUM(*V_UI8REF(pvar));
 #endif
@@ -1574,7 +1575,7 @@ ole_variant2val(VARIANT *pvar)
         else
             obj = UI8_2_NUM(V_UI8(pvar));
         break;
-#endif  /* (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) */
+#endif  /* (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__) */
 
     case VT_R4:
         if(V_ISBYREF(pvar))
@@ -1736,11 +1737,11 @@ reg_get_val(HKEY hkey, const char *subkey)
         if (err == ERROR_SUCCESS) {
             pbuf[size] = '\0';
             if (dwtype == REG_EXPAND_SZ) {
-		char* pbuf2 = (char *)pbuf;
-		DWORD len = ExpandEnvironmentStrings(pbuf2, NULL, 0);
-		pbuf = ALLOC_N(char, len + 1);
-		ExpandEnvironmentStrings(pbuf2, pbuf, len + 1);
-		free(pbuf2);
+                char* pbuf2 = (char *)pbuf;
+                DWORD len = ExpandEnvironmentStrings(pbuf2, NULL, 0);
+                pbuf = ALLOC_N(char, len + 1);
+                ExpandEnvironmentStrings(pbuf2, pbuf, len + 1);
+                free(pbuf2);
             }
             val = rb_str_new2((char *)pbuf);
         }
@@ -2521,12 +2522,12 @@ fole_initialize(int argc, VALUE *argv, VALUE self)
             OLE_RELEASE(pIClassFactory2);
         }
     }
-    pDispatch = p;
     if(FAILED(hr)) {
         ole_raise(hr, eWIN32OLERuntimeError,
                   "failed to create WIN32OLE object from `%s'",
                   StringValuePtr(svr_name));
     }
+    pDispatch = p;
 
     ole_set_member(self, pDispatch);
     return self;
@@ -2554,7 +2555,7 @@ hash2named_arg(VALUE key, VALUE val, VALUE pop)
         rb_raise(rb_eTypeError, "wrong argument type (expected String or Symbol)");
     }
     if (RB_TYPE_P(key, T_SYMBOL)) {
-	key = rb_sym2str(key);
+        key = rb_sym2str(key);
     }
 
     /* pNamedArgs[0] is <method name>, so "index + 1" */
@@ -2618,10 +2619,10 @@ ole_invoke(int argc, VALUE *argv, VALUE self, USHORT wFlags, BOOL is_bracket)
 
     rb_scan_args(argc, argv, "1*", &cmd, &paramS);
     if(!RB_TYPE_P(cmd, T_STRING) && !RB_TYPE_P(cmd, T_SYMBOL) && !is_bracket) {
-	rb_raise(rb_eTypeError, "method is wrong type (expected String or Symbol)");
+        rb_raise(rb_eTypeError, "method is wrong type (expected String or Symbol)");
     }
     if (RB_TYPE_P(cmd, T_SYMBOL)) {
-	cmd = rb_sym2str(cmd);
+        cmd = rb_sym2str(cmd);
     }
     pole = oledata_get_struct(self);
     if(!pole->pDispatch) {
@@ -2630,7 +2631,7 @@ ole_invoke(int argc, VALUE *argv, VALUE self, USHORT wFlags, BOOL is_bracket)
     if (is_bracket) {
         DispID = DISPID_VALUE;
         argc += 1;
-	rb_ary_unshift(paramS, cmd);
+        rb_ary_unshift(paramS, cmd);
     } else {
         wcmdname = ole_vstr2wc(cmd);
         hr = pole->pDispatch->lpVtbl->GetIDsOfNames( pole->pDispatch, &IID_NULL,
@@ -2651,7 +2652,7 @@ ole_invoke(int argc, VALUE *argv, VALUE self, USHORT wFlags, BOOL is_bracket)
         /*------------------------------------------
           hash object ==> named dispatch parameters
         --------------------------------------------*/
-        cNamedArgs = rb_long2int(RHASH_SIZE(param));
+        cNamedArgs = rb_long2int((long)RHASH_SIZE(param));
         op.dp.cArgs = cNamedArgs + argc - 2;
         op.pNamedArgs = ALLOCA_N(OLECHAR*, cNamedArgs + 1);
         op.dp.rgvarg = ALLOCA_N(VARIANTARG, op.dp.cArgs);
@@ -3638,7 +3639,7 @@ fole_respond_to(VALUE self, VALUE method)
     pole = oledata_get_struct(self);
     wcmdname = ole_vstr2wc(method);
     hr = pole->pDispatch->lpVtbl->GetIDsOfNames( pole->pDispatch, &IID_NULL,
-	    &wcmdname, 1, cWIN32OLE_lcid, &DispID);
+            &wcmdname, 1, cWIN32OLE_lcid, &DispID);
     SysFreeString(wcmdname);
     return SUCCEEDED(hr) ? Qtrue : Qfalse;
 }
@@ -3752,7 +3753,7 @@ ole_typedesc2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
     case VT_UI4:
         typestr = rb_str_new2("UI4");
         break;
-#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__)
     case VT_I8:
         typestr = rb_str_new2("I8");
         break;
@@ -3962,6 +3963,7 @@ check_nano_server(void)
     }
 }
 
+LCID cWIN32OLE_lcid;
 
 void
 Init_win32ole(void)

data/ext/win32ole/win32ole.h

@@ -112,8 +112,8 @@ struct oledata {
     IDispatch *pDispatch;
 };
 
-VALUE cWIN32OLE;
-LCID cWIN32OLE_lcid;
+extern VALUE cWIN32OLE;
+extern LCID cWIN32OLE_lcid;
 
 struct oledata *oledata_get_struct(VALUE obj);
 LPWSTR ole_vstr2wc(VALUE vstr);

data/ext/win32ole/win32ole_error.c

@@ -60,6 +60,9 @@ ole_raise(HRESULT hr, VALUE ecs, const char *fmt, ...)
     rb_exc_raise(rb_exc_new_str(ecs, msg));
 }
 
+VALUE eWIN32OLERuntimeError;
+VALUE eWIN32OLEQueryInterfaceError;
+
 void
 Init_win32ole_error(void)
 {

data/ext/win32ole/win32ole_error.h

@@ -1,8 +1,8 @@
 #ifndef WIN32OLE_ERROR_H
 #define WIN32OLE_ERROR_H 1
 
-VALUE eWIN32OLERuntimeError;
-VALUE eWIN32OLEQueryInterfaceError;
+extern VALUE eWIN32OLERuntimeError;
+extern VALUE eWIN32OLEQueryInterfaceError;
 NORETURN(PRINTF_ARGS(void ole_raise(HRESULT hr, VALUE ecs, const char *fmt, ...), 3, 4));
 void Init_win32ole_error(void);
 

data/ext/win32ole/win32ole_event.c

@@ -200,7 +200,7 @@ STDMETHODIMP EVENTSINK_Invoke(
     }
     outargv = Qnil;
     if (is_outarg == Qtrue) {
-	outargv = rb_ary_new();
+        outargv = rb_ary_new();
         rb_ary_push(args, outargv);
     }
 
@@ -413,15 +413,15 @@ hash2ptr_dispparams(VALUE hash, ITypeInfo *pTypeInfo, DISPID dispid, DISPPARAMS
                                      bstrs, pdispparams->cArgs + 1,
                                      &len);
     if (FAILED(hr))
-	return;
+        return;
 
     for (i = 0; i < len - 1; i++) {
-	key = WC2VSTR(bstrs[i + 1]);
+        key = WC2VSTR(bstrs[i + 1]);
         val = rb_hash_aref(hash, RB_UINT2NUM(i));
-	if (val == Qnil)
-	    val = rb_hash_aref(hash, key);
-	if (val == Qnil)
-	    val = rb_hash_aref(hash, rb_str_intern(key));
+        if (val == Qnil)
+            val = rb_hash_aref(hash, key);
+        if (val == Qnil)
+            val = rb_hash_aref(hash, rb_str_intern(key));
         pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
         ole_val2ptr_variant(val, pvar);
     }
@@ -433,7 +433,7 @@ hash2result(VALUE hash)
     VALUE ret = Qnil;
     ret = rb_hash_aref(hash, rb_str_new2("return"));
     if (ret == Qnil)
-	ret = rb_hash_aref(hash, rb_str_intern(rb_str_new2("return")));
+        ret = rb_hash_aref(hash, rb_str_intern(rb_str_new2("return")));
     return ret;
 }
 
@@ -610,7 +610,7 @@ find_coclass(
 
     hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, NULL);
     if (FAILED(hr)) {
-	return hr;
+        return hr;
     }
     count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
     for (i = 0; i < count && !found; i++) {
@@ -1264,7 +1264,8 @@ Init_win32ole_event(void)
     ary_ole_event = rb_ary_new();
     rb_gc_register_mark_object(ary_ole_event);
     id_events = rb_intern("events");
-    cWIN32OLE_EVENT = rb_define_class("WIN32OLE_EVENT", rb_cObject);
+    cWIN32OLE_EVENT = rb_define_class_under(cWIN32OLE, "Event", rb_cObject);
+    rb_define_const(rb_cObject, "WIN32OLE_EVENT", cWIN32OLE_EVENT);
     rb_define_singleton_method(cWIN32OLE_EVENT, "message_loop", fev_s_msg_loop, 0);
     rb_define_alloc_func(cWIN32OLE_EVENT, fev_s_allocate);
     rb_define_method(cWIN32OLE_EVENT, "initialize", fev_initialize, -1);

data/ext/win32ole/win32ole_method.c

@@ -437,7 +437,7 @@ ole_method_invoke_kind(ITypeInfo *pTypeInfo, UINT method_index)
 
 /*
  *   call-seq:
- *      WIN32OLE_MTHOD#invkind
+ *      WIN32OLE_METHOD#invkind
  *
  *   Returns the method invoke kind.
  *     tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Workbooks')
@@ -923,9 +923,12 @@ folemethod_inspect(VALUE self)
     return default_inspect(self, "WIN32OLE_METHOD");
 }
 
+VALUE cWIN32OLE_METHOD;
+
 void Init_win32ole_method(void)
 {
-    cWIN32OLE_METHOD = rb_define_class("WIN32OLE_METHOD", rb_cObject);
+    cWIN32OLE_METHOD = rb_define_class_under(cWIN32OLE, "Method", rb_cObject);
+    rb_define_const(rb_cObject, "WIN32OLE_METHOD", cWIN32OLE_METHOD);
     rb_define_alloc_func(cWIN32OLE_METHOD, folemethod_s_allocate);
     rb_define_method(cWIN32OLE_METHOD, "initialize", folemethod_initialize, 2);
     rb_define_method(cWIN32OLE_METHOD, "name", folemethod_name, 0);

data/ext/win32ole/win32ole_method.h

@@ -7,7 +7,7 @@ struct olemethoddata {
     UINT index;
 };
 
-VALUE cWIN32OLE_METHOD;
+extern VALUE cWIN32OLE_METHOD;
 VALUE folemethod_s_allocate(VALUE klass);
 VALUE ole_methods_from_typeinfo(ITypeInfo *pTypeInfo, int mask);
 VALUE create_win32ole_method(ITypeInfo *pTypeInfo, VALUE name);

data/ext/win32ole/win32ole_param.c

@@ -422,7 +422,8 @@ foleparam_inspect(VALUE self)
 void
 Init_win32ole_param(void)
 {
-    cWIN32OLE_PARAM = rb_define_class("WIN32OLE_PARAM", rb_cObject);
+    cWIN32OLE_PARAM = rb_define_class_under(cWIN32OLE, "Param", rb_cObject);
+    rb_define_const(rb_cObject, "WIN32OLE_PARAM", cWIN32OLE_PARAM);
     rb_define_alloc_func(cWIN32OLE_PARAM, foleparam_s_allocate);
     rb_define_method(cWIN32OLE_PARAM, "initialize", foleparam_initialize, 2);
     rb_define_method(cWIN32OLE_PARAM, "name", foleparam_name, 0);

data/ext/win32ole/win32ole_record.c

@@ -589,10 +589,13 @@ folerecord_inspect(VALUE self)
                       field);
 }
 
+VALUE cWIN32OLE_RECORD;
+
 void
 Init_win32ole_record(void)
 {
-    cWIN32OLE_RECORD = rb_define_class("WIN32OLE_RECORD", rb_cObject);
+    cWIN32OLE_RECORD = rb_define_class_under(cWIN32OLE, "Record", rb_cObject);
+    rb_define_const(rb_cObject, "WIN32OLE_RECORD", cWIN32OLE_RECORD);
     rb_define_alloc_func(cWIN32OLE_RECORD, folerecord_s_allocate);
     rb_define_method(cWIN32OLE_RECORD, "initialize", folerecord_initialize, 2);
     rb_define_method(cWIN32OLE_RECORD, "to_h", folerecord_to_h, 0);

data/ext/win32ole/win32ole_record.h

@@ -1,7 +1,7 @@
 #ifndef WIN32OLE_RECORD_H
 #define WIN32OLE_RECORD_H 1
 
-VALUE cWIN32OLE_RECORD;
+extern VALUE cWIN32OLE_RECORD;
 void ole_rec2variant(VALUE rec, VARIANT *var);
 void olerecord_set_ivar(VALUE obj, IRecordInfo *pri, void *prec);
 VALUE create_win32ole_record(IRecordInfo *pri, void *prec);

data/ext/win32ole/win32ole_type.c

@@ -56,7 +56,7 @@ static const rb_data_type_t oletype_datatype = {
 /*
  * Document-class: WIN32OLE_TYPE
  *
- *   <code>WIN32OLE_TYPE</code> objects represent OLE type libarary information.
+ *   <code>WIN32OLE_TYPE</code> objects represent OLE type library information.
  */
 
 static void
@@ -883,9 +883,12 @@ foletype_inspect(VALUE self)
     return default_inspect(self, "WIN32OLE_TYPE");
 }
 
+VALUE cWIN32OLE_TYPE;
+
 void Init_win32ole_type(void)
 {
-    cWIN32OLE_TYPE = rb_define_class("WIN32OLE_TYPE", rb_cObject);
+    cWIN32OLE_TYPE = rb_define_class_under(cWIN32OLE, "Type", rb_cObject);
+    rb_define_const(rb_cObject, "WIN32OLE_TYPE", cWIN32OLE_TYPE);
     rb_define_singleton_method(cWIN32OLE_TYPE, "ole_classes", foletype_s_ole_classes, 1);
     rb_define_singleton_method(cWIN32OLE_TYPE, "typelibs", foletype_s_typelibs, 0);
     rb_define_singleton_method(cWIN32OLE_TYPE, "progids", foletype_s_progids, 0);

data/ext/win32ole/win32ole_type.h

@@ -1,6 +1,6 @@
 #ifndef WIN32OLE_TYPE_H
 #define WIN32OLE_TYPE_H 1
-VALUE cWIN32OLE_TYPE;
+extern VALUE cWIN32OLE_TYPE;
 VALUE create_win32ole_type(ITypeInfo *pTypeInfo, VALUE name);
 ITypeInfo *itypeinfo(VALUE self);
 VALUE ole_type_from_itypeinfo(ITypeInfo *pTypeInfo);

data/ext/win32ole/win32ole_typelib.c

@@ -285,7 +285,7 @@ oletypelib_get_libattr(ITypeLib *pTypeLib, TLIBATTR **ppTLibAttr)
     hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, ppTLibAttr);
     if (FAILED(hr)) {
         ole_raise(hr, eWIN32OLERuntimeError,
-		  "failed to get library attribute(TLIBATTR) from ITypeLib");
+                  "failed to get library attribute(TLIBATTR) from ITypeLib");
     }
 }
 
@@ -588,13 +588,13 @@ foletypelib_path(VALUE self)
     pTypeLib = itypelib(self);
     oletypelib_get_libattr(pTypeLib, &pTLibAttr);
     hr = QueryPathOfRegTypeLib(&pTLibAttr->guid,
-	                       pTLibAttr->wMajorVerNum,
-			       pTLibAttr->wMinorVerNum,
-			       lcid,
-			       &bstr);
+                               pTLibAttr->wMajorVerNum,
+                               pTLibAttr->wMinorVerNum,
+                               lcid,
+                               &bstr);
     if (FAILED(hr)) {
-	pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
-	ole_raise(hr, eWIN32OLERuntimeError, "failed to QueryPathOfRegTypeTypeLib");
+        pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
+        ole_raise(hr, eWIN32OLERuntimeError, "failed to QueryPathOfRegTypeTypeLib");
     }
 
     pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
@@ -722,7 +722,7 @@ typelib_file_from_typelib(VALUE ole)
             if (ver == Qnil)
                 break;
             err = reg_open_vkey(hclsid, ver, &hversion);
-			if (err != ERROR_SUCCESS || fver > atof(StringValuePtr(ver)))
+                        if (err != ERROR_SUCCESS || fver > atof(StringValuePtr(ver)))
                 continue;
             fver = atof(StringValuePtr(ver));
             typelib = reg_get_val(hversion, NULL);
@@ -822,10 +822,13 @@ foletypelib_inspect(VALUE self)
     return default_inspect(self, "WIN32OLE_TYPELIB");
 }
 
+VALUE cWIN32OLE_TYPELIB;
+
 void
 Init_win32ole_typelib(void)
 {
-    cWIN32OLE_TYPELIB = rb_define_class("WIN32OLE_TYPELIB", rb_cObject);
+    cWIN32OLE_TYPELIB = rb_define_class_under(cWIN32OLE, "Typelib", rb_cObject);
+    rb_define_const(rb_cObject, "WIN32OLE_TYPELIB", cWIN32OLE_TYPELIB);
     rb_define_singleton_method(cWIN32OLE_TYPELIB, "typelibs", foletypelib_s_typelibs, 0);
     rb_define_alloc_func(cWIN32OLE_TYPELIB, foletypelib_s_allocate);
     rb_define_method(cWIN32OLE_TYPELIB, "initialize", foletypelib_initialize, -2);

data/ext/win32ole/win32ole_typelib.h

@@ -1,7 +1,7 @@
 #ifndef WIN32OLE_TYPELIB_H
 #define WIN32OLE_TYPELIB_H 1
 
-VALUE cWIN32OLE_TYPELIB;
+extern VALUE cWIN32OLE_TYPELIB;
 
 void Init_win32ole_typelib(void);
 ITypeLib * itypelib(VALUE self);

data/ext/win32ole/win32ole_variable.c

@@ -365,9 +365,13 @@ folevariable_inspect(VALUE self)
     return make_inspect("WIN32OLE_VARIABLE", detail);
 }
 
+VALUE cWIN32OLE_VARIABLE;
+
 void Init_win32ole_variable(void)
 {
-    cWIN32OLE_VARIABLE = rb_define_class("WIN32OLE_VARIABLE", rb_cObject);
+    cWIN32OLE_VARIABLE = rb_define_class_under(cWIN32OLE, "Variable", rb_cObject);
+    rb_define_const(rb_cObject, "WIN32OLE_VARIABLE", cWIN32OLE_VARIABLE);
+    rb_undef_alloc_func(cWIN32OLE_VARIABLE);
     rb_define_method(cWIN32OLE_VARIABLE, "name", folevariable_name, 0);
     rb_define_method(cWIN32OLE_VARIABLE, "ole_type", folevariable_ole_type, 0);
     rb_define_method(cWIN32OLE_VARIABLE, "ole_type_detail", folevariable_ole_type_detail, 0);

data/ext/win32ole/win32ole_variable.h

@@ -1,7 +1,7 @@
 #ifndef WIN32OLE_VARIABLE_H
 #define WIN32OLE_VARIABLE_H 1
 
-VALUE cWIN32OLE_VARIABLE;
+extern VALUE cWIN32OLE_VARIABLE;
 VALUE create_win32ole_variable(ITypeInfo *pTypeInfo, UINT index, VALUE name);
 void Init_win32ole_variable(void);
 

data/ext/win32ole/win32ole_variant.c

@@ -94,7 +94,7 @@ ole_val2olevariantdata(VALUE val, VARTYPE vt, struct olevariantdata *pvar)
                 }
             }
         }
-#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__)
     } else if ( (vt & ~VT_BYREF) == VT_I8 || (vt & ~VT_BYREF) == VT_UI8) {
         ole_val2variant_ex(val, &(pvar->realvar), (vt & ~VT_BYREF));
         ole_val2variant_ex(val, &(pvar->var), (vt & ~VT_BYREF));
@@ -202,7 +202,7 @@ ole_set_byref(VARIANT *realvar, VARIANT *var,  VARTYPE vt)
             V_R8REF(var) = &V_R8(realvar);
             break;
 
-#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__)
 #ifdef V_I8REF
         case VT_I8:
             V_I8REF(var) = &V_I8(realvar);
@@ -371,7 +371,7 @@ check_type_val2variant(VALUE val)
  *   Win32OLE converts Ruby object into OLE variant automatically when
  *   invoking OLE methods. If OLE method requires the argument which is
  *   different from the variant by automatic conversion of Win32OLE, you
- *   can convert the specfied variant type by using WIN32OLE_VARIANT class.
+ *   can convert the specified variant type by using WIN32OLE_VARIANT class.
  *
  *     param = WIN32OLE_VARIANT.new(10, WIN32OLE::VARIANT::VT_R4)
  *     oleobj.method(param)
@@ -689,11 +689,14 @@ ole_variant2variant(VALUE val, VARIANT *var)
     VariantCopy(var, &(pvar->var));
 }
 
+VALUE cWIN32OLE_VARIANT;
+
 void
 Init_win32ole_variant(void)
 {
 #undef rb_intern
-    cWIN32OLE_VARIANT = rb_define_class("WIN32OLE_VARIANT", rb_cObject);
+    cWIN32OLE_VARIANT = rb_define_class_under(cWIN32OLE, "Variant", rb_cObject);
+    rb_define_const(rb_cObject, "WIN32OLE_VARIANT", cWIN32OLE_VARIANT);
     rb_define_alloc_func(cWIN32OLE_VARIANT, folevariant_s_allocate);
     rb_define_singleton_method(cWIN32OLE_VARIANT, "array", folevariant_s_array, 2);
     rb_define_method(cWIN32OLE_VARIANT, "initialize", folevariant_initialize, -2);

data/ext/win32ole/win32ole_variant.h

@@ -1,7 +1,7 @@
 #ifndef WIN32OLE_VARIANT_H
 #define WIN32OLE_VARIANT_H 1
 
-VALUE cWIN32OLE_VARIANT;
+extern VALUE cWIN32OLE_VARIANT;
 void ole_variant2variant(VALUE val, VARIANT *var);
 void Init_win32ole_variant(void);
 

data/ext/win32ole/win32ole_variant_m.c

@@ -1,5 +1,7 @@
 #include "win32ole.h"
 
+VALUE mWIN32OLE_VARIANT;
+
 void Init_win32ole_variant_m(void)
 {
     /*
@@ -114,7 +116,7 @@ void Init_win32ole_variant_m(void)
      */
     rb_define_const(mWIN32OLE_VARIANT, "VT_UI4", RB_INT2FIX(VT_UI4));
 
-#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
+#if (defined(_MSC_VER) && (_MSC_VER >= 1300)) || defined(__CYGWIN__) || defined(__MINGW32__)
     /*
      * represents VT_I8 type constant.
      */

data/ext/win32ole/win32ole_variant_m.h

@@ -1,7 +1,7 @@
 #ifndef WIN32OLE_VARIANT_M_H
 #define WIN32OLE_VARIANT_M_H 1
 
-VALUE mWIN32OLE_VARIANT;
+extern VALUE mWIN32OLE_VARIANT;
 void Init_win32ole_variant_m(void);
 
 #endif

data/rakelib/changelogs.rake

@@ -0,0 +1,34 @@
+task "build" => "changelogs"
+
+changelog = proc do |output, ver = nil, prev = nil|
+  ver &&= Gem::Version.new(ver)
+  range = [[prev], [ver, "HEAD"]].map {|ver, branch| ver ? "v#{ver.to_s}" : branch}.compact.join("..")
+  IO.popen(%W[git log --format=fuller --topo-order --no-merges #{range}]) do |log|
+    line = log.gets
+    FileUtils.mkpath(File.dirname(output))
+    File.open(output, "wb") do |f|
+      f.print "-*- coding: utf-8 -*-\n\n", line
+      log.each_line do |line|
+        line.sub!(/^(?!:)(?:Author|Commit)?(?:Date)?: /, '  \&')
+        line.sub!(/ +$/, '')
+        f.print(line)
+      end
+    end
+  end
+end
+
+tags = IO.popen(%w[git tag -l v[0-9]*]).grep(/v(.*)/) {$1}
+tags.sort_by! {|tag| tag.scan(/\d+/).map(&:to_i)}
+tags.inject(nil) do |prev, tag|
+  task("logs/ChangeLog-#{tag}") {|t| changelog[t.name, tag, prev]}
+  tag
+end
+
+desc "Make ChangeLog"
+task "ChangeLog", [:ver, :prev] do |t, ver: nil, prev: tags.last|
+  changelog[t.name, ver, prev]
+end
+
+changelogs = ["ChangeLog", *tags.map {|tag| "logs/ChangeLog-#{tag}"}]
+task "changelogs" => changelogs
+CLOBBER.concat(changelogs) << "logs"

data/rakelib/epoch.rake

@@ -0,0 +1,5 @@
+task "build" => "date_epoch"
+
+task "date_epoch" do
+  ENV["SOURCE_DATE_EPOCH"] = IO.popen(%W[git -C #{__dir__} log -1 --format=%ct], &:read).chomp
+end

data/rakelib/version.rake

@@ -0,0 +1,45 @@
+class << (helper = Bundler::GemHelper.instance)
+  SOURCE_PATH = "ext/stringio/stringio.c"
+  def update_source_version
+    path = SOURCE_PATH
+    File.open(path, "r+b") do |f|
+      d = f.read
+      if d.sub!(/^#define\s+STRINGIO_VERSION\s+\K".*"/) {version.to_s.dump}
+        f.rewind
+        f.truncate(0)
+        f.print(d)
+      end
+    end
+  end
+
+  def commit_bump
+    sh(%W[git commit -m bump\ up\ to\ #{gemspec.version}
+          #{SOURCE_PATH}])
+  end
+
+  def version=(v)
+    gemspec.version = v
+    update_source_version
+    commit_bump
+  end
+end
+
+major, minor, teeny = helper.gemspec.version.segments
+
+task "bump:teeny" do
+  helper.version = Gem::Version.new("#{major}.#{minor}.#{teeny+1}")
+end
+
+task "bump:minor" do
+  helper.version = Gem::Version.new("#{major}.#{minor+1}.0")
+end
+
+task "bump:major" do
+  helper.version = Gem::Version.new("#{major+1}.0.0")
+end
+
+task "bump" => "bump:teeny"
+
+task "tag" do
+  helper.__send__(:tag_version)
+end

data/win32ole.gemspec

@@ -1,6 +1,16 @@
+source_version = ["", "ext/win32ole/"].find do |dir|
+  begin
+    break File.open(File.join(__dir__, "#{dir}win32ole.c")) {|f|
+      f.gets("\n#define WIN32OLE_VERSION ")
+      f.gets[/\s*"(.+)"/, 1]
+    }
+  rescue Errno::ENOENT
+  end
+end
+
 Gem::Specification.new do |spec|
   spec.name          = "win32ole"
-  spec.version       = "1.8.8"
+  spec.version       = source_version
   spec.authors       = ["Masaki Suketa"]
   spec.email         = ["suke@ruby-lang.org"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: win32ole
 version: !ruby/object:Gem::Version
-  version: 1.8.8
+  version: 1.8.10
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-03 00:00:00.000000000 Z
+date: 2023-11-07 00:00:00.000000000 Z
 dependencies: []
 description: Provides an interface for OLE Automation in Ruby
 email:
@@ -17,8 +17,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".git-blame-ignore-revs"
+- ".github/dependabot.yml"
+- ".github/workflows/windows.yml"
 - ".gitignore"
-- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -61,6 +63,9 @@ files:
 - ext/win32ole/win32ole_variant_m.h
 - lib/win32ole.rb
 - lib/win32ole/property.rb
+- rakelib/changelogs.rake
+- rakelib/epoch.rake
+- rakelib/version.rake
 - win32ole.gemspec
 homepage: https://github.com/ruby/win32ole
 licenses:
@@ -84,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.2
+rubygems_version: 3.5.0.dev
 signing_key:
 specification_version: 4
 summary: Provides an interface for OLE Automation in Ruby

data/.travis.yml

@@ -1,6 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - 2.8.0
-before_install: gem install bundler -v 2.1.4