google-cloud-datastore 2.2.3 → 2.2.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: e5a916b746fc52de5e51b15ba2e9f78bfa8a007017be5e2c9f79aa73ed5e7375
4
- data.tar.gz: beaf302cd7963e9da82ec1fde9fa9079f73660688e7ca52cb9fa3d6a8a3aa7a0
3
+ metadata.gz: 226ab9998e7737ce7e7aa4106ed0d16ce04774f192b26dc0770d8d9a8dd57b87
4
+ data.tar.gz: c641a2aa53f1d4f5a39ec603b0cfd998fa57b71841b4e9b52dafb623dc71a76e
5
5
  SHA512:
6
- metadata.gz: 0f96129ab0a9640752375f94c605825c10ebcb6e60c5c83cf574a1db8a76e1ef2eef3ed7d4a56b823985f7e39e1eb842b6fe45e89788d773fd3adfe25e9d0f93
7
- data.tar.gz: 8d19db5f56e24bfae7dfafbac92d8134a3ee30832c5decb8b0951353c0fc432e3ff1e854c245213a468a5ebdba6f03024ebf214da5242e70fa711b608a536af3
6
+ metadata.gz: 72ffee894e6ee4fff6651a65ed90a0f7c0b05b9be61730c2677080fffb2530a07bd3e81eac36ca2cb137b1a3a1c41e18dbc59fc4837b99bcbb7d27c0a786f1f7
7
+ data.tar.gz: 5febeb8616ddb1972a7b52ec4450ee63f84ecad99ad535032de261aa7055edafbd7b2822bed53ea95b3df5ef66f8c01fd7d577bbe2bb65661cfdd78133502031
data/CHANGELOG.md CHANGED
@@ -1,5 +1,11 @@
1
1
  # Release History
2
2
 
3
+ ### 2.2.4 / 2022-01-11
4
+
5
+ #### Documentation
6
+
7
+ * Update contributing docs
8
+
3
9
  ### 2.2.3 / 2021-10-21
4
10
 
5
11
  #### Documentation
data/CONTRIBUTING.md CHANGED
@@ -1,209 +1,401 @@
1
1
  # Contributing to Google Cloud Datastore
2
2
 
3
- 1. **Sign one of the contributor license agreements below.**
4
- 2. Fork the repo, develop and test your code changes.
5
- 3. Send a pull request.
3
+ Thank you for your interest in making a contribution to google-cloud-ruby. Community contributions are an essential part
4
+ of open source, and we want to make contributing easy for you. If you have any suggestions for how to improve this
5
+ guide, please [open an issue](https://github.com/googleapis/google-cloud-ruby/issues) and let us know!
6
6
 
7
- ## Contributor License Agreements
7
+ ### Code of Conduct
8
8
 
9
- Before we can accept your pull requests you'll need to sign a Contributor
10
- License Agreement (CLA):
9
+ Please note that this project is covered by a Contributor Code of Conduct. By participating in this project you agree to
10
+ abide by its terms. See {file:CODE_OF_CONDUCT.md Code of Conduct} for more information.
11
11
 
12
- - **If you are an individual writing original source code** and **you own the
13
- intellectual property**, then you'll need to sign an [individual
14
- CLA](https://developers.google.com/open-source/cla/individual).
15
- - **If you work for a company that wants to allow you to contribute your work**,
16
- then you'll need to sign a [corporate
12
+ ## Overview
13
+
14
+ 1. [Open an issue](#open-an-issue)
15
+ 1. [Sign Contributor License Agreement](#sign-contributor-license-agreement)
16
+ 1. [Set up environment](#set-up-environment)
17
+ 1. [Run CI](#run-ci)
18
+ 1. [Make changes](#make-changes)
19
+ 1. [Commit changes](#commit-changes)
20
+ 1. [Run CI again](#run-ci-again)
21
+ 1. [Submit your pull request](#submit-your-pull-request)
22
+
23
+ ## Open an issue
24
+
25
+ Pull requests should generally be directed by an existing issue, otherwise you risk working on something that the
26
+ maintainers might not be able to accept into the project. Please take a look through [the repository
27
+ issues](https://github.com/googleapis/google-cloud-ruby/issues?q=is%3Aissue+label%3A%22api%3A+datastore%22), and if you
28
+ do not see an existing issue for your problem or feature, please open one using one of the provided templates.
29
+
30
+ ## Sign Contributor License Agreement
31
+
32
+ Before we can accept your pull requests you'll need to sign a Contributor License Agreement (CLA):
33
+
34
+ - **If you are an individual writing original source code** and **you own the intellectual property**, then you'll need
35
+ to sign an [individual CLA](https://developers.google.com/open-source/cla/individual).
36
+ - **If you work for a company that wants to allow you to contribute your work**, then you'll need to sign a [corporate
17
37
  CLA](https://developers.google.com/open-source/cla/corporate).
18
38
 
19
- You can sign these electronically (just scroll to the bottom). After that, we'll
20
- be able to accept your pull requests.
39
+ You can sign these electronically. After that, we'll be able to accept your pull requests.
40
+
41
+ ## Set up environment
21
42
 
22
- ## Setup
43
+ Before you start on a pull request, you should prepare your work environment for development, acceptance testing and the
44
+ interactive console (optional).
23
45
 
24
- In order to use the google-cloud-datastore console and run the project's tests,
25
- there is a small amount of setup:
46
+ ### Local development setup
26
47
 
27
- 1. Install Ruby. google-cloud-datastore requires Ruby 2.5+. You may choose to
28
- manage your Ruby and gem installations with [RVM](https://rvm.io/),
29
- [rbenv](https://github.com/rbenv/rbenv), or
30
- [chruby](https://github.com/postmodern/chruby).
48
+ To set up your local development environment:
31
49
 
32
- 2. Install [Bundler](http://bundler.io/).
50
+ 1. Install a [supported version](google-cloud-datastore.gemspec) (or versions) of Ruby. (You may choose to manage your
51
+ Ruby and gem installations with [RVM](https://rvm.io/), [rbenv](https://github.com/rbenv/rbenv),
52
+ [chruby](https://github.com/postmodern/chruby) or a similar tool.)
53
+
54
+ 1. Install [Bundler](http://bundler.io/).
33
55
 
34
56
  ```sh
35
57
  $ gem install bundler
36
58
  ```
37
59
 
38
- 3. Install the top-level project dependencies.
60
+ 1. [Fork](https://docs.github.com/en/github/collaborating-with-pull-requests/working-with-forks) the
61
+ [google-cloud-ruby](https://github.com/googleapis/google-cloud-ruby) repo, clone your fork, and configure the
62
+ `upstream`
63
+ [remote](https://docs.github.com/en/github/collaborating-with-pull-requests/working-with-forks/configuring-a-remote-for-a-fork):
64
+
65
+ ```bash
66
+ git clone https://github.com/<your-username>/google-cloud-ruby.git
67
+ cd google-cloud-ruby
68
+ git remote add upstream git@github.com:googleapis/google-cloud-ruby.git
69
+ ```
70
+
71
+ 1. If your fork and clone are not brand new, get the latest changes from `upstream`:
72
+
73
+ ```bash
74
+ git checkout main
75
+ git pull upstream main
76
+ ```
77
+
78
+ 1. Change to the library's sub-directory in the repo:
39
79
 
40
80
  ```sh
41
- $ bundle install
81
+ $ cd google-cloud-datastore
42
82
  ```
43
83
 
44
- 4. Install the Datastore dependencies.
84
+ 1. Install (or update) the library dependencies:
45
85
 
46
86
  ```sh
47
- $ cd google-cloud-datastore/
48
- $ bundle install
87
+ $ bundle update
49
88
  ```
50
89
 
51
- ## Console
90
+ 1. Create a new topic branch off of the `main` branch:
52
91
 
53
- In order to run code interactively, you can automatically load
54
- google-cloud-datastore and its dependencies in IRB. This requires that your
55
- developer environment has already been configured by following the steps
56
- described in the {file:AUTHENTICATION.md Authentication Guide}. An IRB console
57
- can be created with:
92
+ ```bash
93
+ git checkout -b <topic-branch>
94
+ ```
58
95
 
59
- ```sh
60
- $ cd google-cloud-datastore/
61
- $ bundle exec rake console
62
- ```
96
+ ### Acceptance tests setup
97
+
98
+ To set up your acceptance test credentials:
99
+
100
+ 1. If needed, create a Google Cloud project. In the Google Cloud Console, on the project selector page, select or create
101
+ a project.
102
+
103
+ 1. Ensure that billing is enabled for your project.
63
104
 
64
- ## Datastore Tests
105
+ 1. Ensure that the Datastore API is enabled for your project. Note that if you have already enabled the Firestore API
106
+ for your project, you will need to use a different project for Datastore.
65
107
 
66
- Tests are very important part of google-cloud-datastore. All contributions
67
- should include tests that ensure the contributed code behaves as expected.
108
+ 1. Follow the instructions for [Creating a Service Account](AUTHENTICATION.md#creating-a-service-account) in
109
+ `AUTHENTICATION.md`, including downloading and securely storing a JSON key file.
68
110
 
69
- To run the unit tests, documentation tests, and code style checks together for a
70
- package:
111
+ 1. Set the `GCLOUD_TEST_KEYFILE` environment variable to the path of the JSON key file that you downloaded in the
112
+ previous step:
113
+
114
+ ``` sh
115
+ $ export GCLOUD_TEST_KEYFILE=/path/to/keyfile.json
116
+ ```
117
+
118
+ If you are already using the `GCLOUD_TEST_KEYFILE` environment variable, and wish to test this library with a
119
+ different key file, you may set the `DATASTORE_TEST_KEYFILE` environment variable instead:
120
+
121
+ ``` sh
122
+ $ export DATASTORE_TEST_KEYFILE=/path/to/keyfile.json
123
+ ```
124
+
125
+ 1. Set the `GCLOUD_TEST_PROJECT` environment variable to your Google Cloud project ID:
126
+
127
+ ``` sh
128
+ $ export GCLOUD_TEST_PROJECT=my-project-id
129
+ ```
130
+
131
+ If you are already using the `GCLOUD_TEST_PROJECT` environment variable, and wish to test this library with a
132
+ different project, you may set the `DATASTORE_TEST_PROJECT` environment variable instead:
133
+
134
+ ``` sh
135
+ $ export DATASTORE_TEST_PROJECT=my-project-id
136
+ ```
137
+
138
+ ### Interactive console setup (optional)
139
+
140
+ To set up your interactive console credentials:
141
+
142
+ 1. Set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to the path of your service account JSON key file (see
143
+ above):
144
+
145
+ ``` sh
146
+ $ export GOOGLE_APPLICATION_CREDENTIALS=/path/to/keyfile.json
147
+ ```
148
+
149
+ If you are already using the `GOOGLE_APPLICATION_CREDENTIALS` environment variable, and wish to test this library
150
+ with a different key file, you may set the `DATASTORE_CREDENTIALS` environment variable instead:
151
+
152
+ ``` sh
153
+ $ export DATASTORE_CREDENTIALS=/path/to/keyfile.json
154
+ ```
155
+
156
+ 1. Set the `GOOGLE_CLOUD_PROJECT` environment variable to your Google Cloud project ID:
157
+
158
+ ``` sh
159
+ $ export GOOGLE_CLOUD_PROJECT=my-project-id
160
+ ```
161
+
162
+ If you are already using the `GOOGLE_CLOUD_PROJECT` environment variable, and wish to test this library with a
163
+ different project, you may set the `DATASTORE_PROJECT` environment variable instead:
164
+
165
+ ``` sh
166
+ $ export DATASTORE_PROJECT=my-project-id
167
+ ```
168
+
169
+
170
+ ## Run CI
171
+
172
+ You are now ready to run local CI checks for the library, which you should do **before** you make any changes. Doing so
173
+ ensures that everything is OK with your local environment and the latest dependency versions. You don't want any
174
+ surprises later.
175
+
176
+ If you haven't already done so, change to the library's sub-directory in the repo:
177
+
178
+ ```sh
179
+ $ cd google-cloud-datastore
180
+ ```
181
+
182
+ To run the code style checks, documentation tests, and unit tests together, use the `ci` task:
71
183
 
72
184
  ``` sh
73
- $ cd google-cloud-datastore/
74
185
  $ bundle exec rake ci
75
186
  ```
76
187
 
77
- To run the command above, plus all acceptance tests, use `rake ci:acceptance` or
78
- its handy alias, `rake ci:a`.
188
+ To run the command above, plus all acceptance tests, use `rake ci:acceptance` or its handy alias, `rake ci:a`. Keep in
189
+ mind that the acceptance tests typically take longer than the other CI checks and require authentication credentials.
190
+ See the [Acceptance tests](#Acceptance-tests) section below for more information.
79
191
 
80
- ### Datastore Unit Tests
192
+ The Rake tasks aggregated in the commands above can be run individually to streamline your workflow when developing or
193
+ debugging.
81
194
 
195
+ | CI check | Command |
196
+ |-----------------------------------------------|------------------ |
197
+ | [Static code analysis](#Static-code-analysis) | `rake rubocop` |
198
+ | [Documentation tests](#Documentation-tests) | `rake doctest` |
199
+ | [Unit tests](#Unit-tests) | `rake test` |
200
+ | [Acceptance tests](#Acceptance-tests) | `rake acceptance` |
82
201
 
83
- The project uses the [minitest](https://github.com/seattlerb/minitest) library,
84
- including [specs](https://github.com/seattlerb/minitest#specs),
85
- [mocks](https://github.com/seattlerb/minitest#mocks) and
86
- [minitest-autotest](https://github.com/seattlerb/minitest-autotest).
202
+ The subsections below describe the individual CI checks.
87
203
 
88
- To run the Datastore unit tests:
204
+ ### Static code analysis
89
205
 
90
- ``` sh
91
- $ cd google-cloud-datastore/
92
- $ bundle exec rake test
206
+ The project uses [Rubocop](https://github.com/rubocop/rubocop) configured with the shared
207
+ [googleapis/ruby-style](https://github.com/googleapis/ruby-style) rules to ensure that your code adheres to
208
+ Google's Ruby style. The style is largely based on [The Ruby Style
209
+ Guide](https://github.com/bbatsov/ruby-style-guide) with a few exceptions:
210
+
211
+ * Avoid parentheses when possible, including in method definitions.
212
+ * Use double-quoted strings.
213
+
214
+ You can check your code against these rules by running the Rubocop Rake task:
215
+
216
+ ```sh
217
+ $ bundle exec rake rubocop
93
218
  ```
94
219
 
95
- ### Datastore Documentation Tests
220
+ In the rare case that you need to override the existing Rubocop configuration for this library in order to accommodate
221
+ your changes, you can do so by updating [.rubocop.yml](.rubocop.yml).
96
222
 
97
- The project tests the code examples in the gem's
98
- [YARD](https://github.com/lsegal/yard)-based documentation.
223
+ ### Documentation tests
99
224
 
100
- The example testing functions in a way that is very similar to unit testing, and
101
- in fact the library providing it,
102
- [yard-doctest](https://github.com/p0deje/yard-doctest), is based on the
103
- project's unit test library, [minitest](https://github.com/seattlerb/minitest).
225
+ When adding a new feature, you should almost always add one or more in-line documentation code examples demonstrating
226
+ the use of the feature, using [YARD](https://github.com/lsegal/yard)'s
227
+ [`@example`](http://www.rubydoc.info/gems/yard/file/docs/Tags.md#example) tag. Be sure to write a complete, executable
228
+ example that includes the library `require` statement and client initialization.
104
229
 
105
- To run the Datastore documentation tests:
230
+ The project uses [yard-doctest](https://github.com/p0deje/yard-doctest) to execute each sample as a unit test:
106
231
 
107
232
  ``` sh
108
- $ cd google-cloud-datastore/
109
233
  $ bundle exec rake doctest
110
234
  ```
111
235
 
112
- If you add, remove or modify documentation examples when working on a pull
113
- request, you may need to update the setup for the tests. The stubs and mocks
114
- required to run the tests are located in `support/doctest_helper.rb`. Please
115
- note that much of the setup is matched by the title of the
116
- [`@example`](http://www.rubydoc.info/gems/yard/file/docs/Tags.md#example) tag.
117
- If you alter an example's title, you may encounter breaking tests.
236
+ If you add, remove or modify documentation examples, you may need to update the setup for the tests. The fixtures, stubs
237
+ and mocks required to run the tests are located in [support/doctest_helper.rb](support/doctest_helper.rb). Please note
238
+ that much of the setup is matched to its corresponding example by the title of the `@example` tag. If you alter an
239
+ example's title, you may encounter broken tests.
118
240
 
119
- ### Datastore Acceptance Tests
241
+ There are generally no assertions or mock verifications in these tests. They simply check that the examples are
242
+ syntactically correct and execute against the library source code without error.
120
243
 
121
- The Datastore acceptance tests interact with the live service API. Follow the
122
- instructions in the {file:AUTHENTICATION.md Authentication Guide} for enabling
123
- the Datastore API. Occasionally, some API features may not yet be generally
124
- available, making it difficult for some contributors to successfully run the
125
- entire acceptance test suite. However, please ensure that you do successfully
126
- run acceptance tests for any code areas covered by your pull request.
244
+ ### Unit tests
127
245
 
128
- To run the acceptance tests, first create and configure a project in the Google
129
- Developers Console, as described in the {file:AUTHENTICATION.md Authentication
130
- guide}. Be sure to download the JSON KEY file. Make note of the PROJECT_ID and
131
- the KEYFILE location on your system.
246
+ The project uses the [minitest](https://github.com/seattlerb/minitest) library, including
247
+ [specs](https://github.com/seattlerb/minitest#specs-), [mocks](https://github.com/seattlerb/minitest#mocks-),
248
+ [minitest-autotest](https://github.com/seattlerb/minitest-autotest), and
249
+ [minitest-focus](https://github.com/seattlerb/minitest-focus).
132
250
 
133
- Before you can run the Datastore acceptance tests, you must first create indexes
134
- used in the tests.
251
+ To run the unit tests:
135
252
 
136
- #### Create Datastore indexes
253
+ ``` sh
254
+ $ bundle exec rake test
255
+ ```
137
256
 
138
- Install the [gcloud command-line
139
- tool](https://developers.google.com/cloud/sdk/gcloud/) and use it to create the
140
- indexes used in the datastore acceptance tests. From the project's root
141
- directory:
257
+ Although the unit tests are intended to run quickly, during development or debugging you may want to isolate one or more
258
+ of the tests by placing the `focus` keyword just above the test declaration. (See
259
+ [minitest-focus](https://github.com/seattlerb/minitest-focus) for details.)
142
260
 
143
- ``` sh
144
- # Install the app component
145
- $ gcloud components update app
261
+ ### Acceptance Tests
146
262
 
147
- # Set the default project in your env
148
- $ gcloud config set project PROJECT_ID
263
+ The acceptance tests (a.k.a. integration tests) ensure that the library works correctly against the live service API.
264
+ To configure your Google Cloud project, see [Acceptance tests setup](#acceptance-tests-setup) above.
149
265
 
150
- # Authenticate the gcloud tool with your account
151
- $ gcloud auth login
266
+ **Warning: You may incur charges while running the acceptance tests against your Google Cloud project.**
152
267
 
153
- # Create the indexes
154
- $ gcloud preview datastore create-indexes acceptance/data/
155
- ```
268
+ Like the unit tests, the acceptance tests are based on the [minitest](https://github.com/seattlerb/minitest) library,
269
+ including [specs](https://github.com/seattlerb/minitest#specs-) and
270
+ [minitest-focus](https://github.com/seattlerb/minitest-focus). Mocks are not generally used in acceptance tests.
156
271
 
157
- #### Running the Datastore acceptance tests
272
+ Because the acceptance test suite is often time-consuming to run in its entirety, during development or debugging you
273
+ may want to isolate one or more of the tests by placing the `focus` keyword just above the test declaration. (See
274
+ [minitest-focus](https://github.com/seattlerb/minitest-focus) for details.)
158
275
 
159
- To run the Datastore acceptance tests:
276
+ To run the acceptance tests:
160
277
 
161
278
  ``` sh
162
- $ cd google-cloud-datastore/
163
- $ bundle exec rake acceptance[\\{my-project-id},\\{/path/to/keyfile.json}]
279
+ $ bundle exec rake acceptance
164
280
  ```
165
281
 
166
- Or, if you prefer you can store the values in the `GCLOUD_TEST_PROJECT` and
167
- `GCLOUD_TEST_KEYFILE` environment variables:
282
+ Some acceptance tests may depend on API features that are not yet generally available, and will fail unless your project
283
+ is added to an internal allowlist. There may also be tests that usually pass but fail occasionally due to issues like
284
+ eventual consistency. However, please ensure that you do successfully run acceptance tests for any code areas covered by
285
+ your pull request.
168
286
 
169
- ``` sh
170
- $ cd google-cloud-datastore/
171
- $ export GCLOUD_TEST_PROJECT=\\{my-project-id}
172
- $ export GCLOUD_TEST_KEYFILE=\\{/path/to/keyfile.json}
173
- $ bundle exec rake acceptance
287
+ ## Make changes
288
+
289
+ All contributions should include new or updated tests to ensure that the contributed code behaves as expected.
290
+
291
+ When starting work on a new feature, it often makes sense to begin with a basic acceptance test to ensure that the new
292
+ feature is present in the live service API and is available to your project. To run your new test exclusively,
293
+ temporarily add the `focus` keyword just above the test declaration. (See
294
+ [minitest-focus](https://github.com/seattlerb/minitest-focus) for details.) Also, the acceptance tests have a retry
295
+ mechanism that can sometimes make it hard to see the correct error when things go wrong. To disable retries while
296
+ debugging errors, temporarily comment out or remove the `run_one_method` method definition in
297
+ [acceptance/datastore_helper.rb](acceptance/datastore_helper.rb).
298
+
299
+ When you are done developing, be sure to remove any usages of the `focus` keyword from your tests and restore the
300
+ `run_one_method` method definition if you removed it.
301
+
302
+ ### Console
303
+
304
+ The project includes a Rake task that automatically loads `google-cloud-datastore` and its dependencies in IRB. To
305
+ configure your Google Cloud project for IRB, see [Interactive console setup](#interactive-console-setup-optional) above.
306
+
307
+ **Warning: You may incur charges while using the library with your Google Cloud project.**
308
+
309
+ If you haven't already done so, change to the library's sub-directory in the repo:
310
+
311
+ ```sh
312
+ $ cd google-cloud-datastore
174
313
  ```
175
314
 
176
- If you want to use a different project and credentials for acceptance tests, you
177
- can use the more specific `DATASTORE_TEST_PROJECT` and `DATASTORE_TEST_KEYFILE`
178
- environment variables:
315
+ The preloaded IRB console can be used as follows:
179
316
 
180
- ``` sh
181
- $ cd google-cloud-datastore/
182
- $ export DATASTORE_TEST_PROJECT=\\{my-project-id}
183
- $ export DATASTORE_TEST_KEYFILE=\\{/path/to/keyfile.json}
184
- $ bundle exec rake acceptance
317
+ ```sh
318
+ $ bundle exec rake console
319
+ irb(main):001:0> require "google/cloud/datastore"
320
+ => true
321
+ irb(main):002:0> datastore = Google::Cloud::Datastore.new
185
322
  ```
186
323
 
187
- ## Coding Style
324
+ Using the console provides an interactive alternative to acceptance testing that may make it easier to explore usage and
325
+ debug problems.
188
326
 
189
- Please follow the established coding style in the library. The style is is
190
- largely based on [The Ruby Style
191
- Guide](https://github.com/bbatsov/ruby-style-guide) with a few exceptions based
192
- on seattle-style:
327
+ ## Commit changes
193
328
 
194
- * Avoid parenthesis when possible, including in method definitions.
195
- * Always use double quotes strings. ([Option
196
- B](https://github.com/bbatsov/ruby-style-guide#strings))
329
+ Commit your changes using [conventional commits](https://www.conventionalcommits.org/), making sure to include the
330
+ associated GitHub issue number. Below is an example of a `feat` type commit that will result in a semver `minor`
331
+ release. Notice how it is scoped to the short name of the library, contains a bulleted list of public API changes, and
332
+ ends with the `closes` GitHub keyword. If this is the only new commit in your branch when you open your pull request,
333
+ the commit body including the `closes` phrase will be copied to your PR description. If you have multiple commits, you
334
+ should copy the body of this anchor commit manually to the PR description, so that GitHub will [automatically close the
335
+ related issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue).
197
336
 
198
- You can check your code against these rules by running Rubocop like so:
337
+ ```bash
338
+ git commit -am "feat(datastore): Add my new feature
199
339
 
200
- ```sh
201
- $ cd google-cloud-datastore/
202
- $ bundle exec rake rubocop
340
+ * Add MyClass#my_method
341
+
342
+ closes: #123"
203
343
  ```
204
344
 
205
- ## Code of Conduct
345
+ The messages for any subsequent commits you may add do not necessarily need to follow the conventional commits format,
346
+ as these messages will be manually dropped or added as bullet points to the original message when the PR is squashed and
347
+ merged.
348
+
349
+ ## Run CI again
350
+
351
+
352
+ 1. If you haven't already done so, change to the library's sub-directory in the repo:
353
+
354
+ ```sh
355
+ $ cd google-cloud-datastore
356
+ ```
357
+
358
+ 1. Rebase your topic branch on the upstream `main` branch:
359
+
360
+ ```bash
361
+ git pull --rebase upstream main
362
+ ```
363
+
364
+ 1. Run the `ci` task:
365
+
366
+ ``` sh
367
+ $ bundle exec rake ci
368
+ ```
369
+
370
+ 1. Run the `acceptance` task:
371
+
372
+ ``` sh
373
+ $ bundle exec rake acceptance
374
+ ```
375
+
376
+ Ensure that everything is passing in `rake ci` and `rake acceptance`, or at least that `rake ci` is green and you
377
+ haven't broken anything new in `rake acceptance`, before you open your pull request.
378
+
379
+ ## Submit your pull request
380
+
381
+ 1. Rebase your topic branch on the upstream `main` branch:
382
+
383
+ ```bash
384
+ git pull --rebase upstream main
385
+ ```
386
+
387
+ 1. Push your topic branch to your fork:
388
+
389
+ ```bash
390
+ git push origin -u
391
+ ```
392
+
393
+ 1. Open a [pull
394
+ request](https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests)
395
+ using the first line of your conventional commit as the title, and with the associated GitHub issue in the
396
+ description. By convention in this project, the assignee of the pull request will be the maintainer who will merge it
397
+ once it is approved. If you are a maintainer of the project, typically you should assign the pull request to
398
+ yourself.
399
+
400
+ 1. Ensure that all of the GitHub checks are passing.
206
401
 
207
- Please note that this project is released with a Contributor Code of Conduct. By
208
- participating in this project you agree to abide by its terms. See
209
- {file:CODE_OF_CONDUCT.md Code of Conduct} for more information.
@@ -16,7 +16,7 @@
16
16
  module Google
17
17
  module Cloud
18
18
  module Datastore
19
- VERSION = "2.2.3".freeze
19
+ VERSION = "2.2.4".freeze
20
20
  end
21
21
  end
22
22
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: google-cloud-datastore
3
3
  version: !ruby/object:Gem::Version
4
- version: 2.2.3
4
+ version: 2.2.4
5
5
  platform: ruby
6
6
  authors:
7
7
  - Mike Moore
@@ -9,7 +9,7 @@ authors:
9
9
  autorequire:
10
10
  bindir: bin
11
11
  cert_chain: []
12
- date: 2021-10-21 00:00:00.000000000 Z
12
+ date: 2022-01-11 00:00:00.000000000 Z
13
13
  dependencies:
14
14
  - !ruby/object:Gem::Dependency
15
15
  name: google-cloud-core
@@ -235,7 +235,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
235
235
  - !ruby/object:Gem::Version
236
236
  version: '0'
237
237
  requirements: []
238
- rubygems_version: 3.2.17
238
+ rubygems_version: 3.3.4
239
239
  signing_key:
240
240
  specification_version: 4
241
241
  summary: API Client library for Google Cloud Datastore