my_john_deere_api 0.15.4 → 0.15.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb000ae1403d9597e7880a972c46f5e2a9f9ca9326107d11e0ea1da2489a6ec6
-  data.tar.gz: e0f861b52d8a82465fd12eafcf8071779d5a72c05fc29d33ae46e8a1599b22cb
+  metadata.gz: 50683e3b5739e473385b52c3ff9e7bcdabb74410c004fa13e9349de03c7eca43
+  data.tar.gz: f7b612049d14d825bbf78831e2a2f4b19370df18ddde3a114b277494d4ba45c6
 SHA512:
-  metadata.gz: 199148536c1277155460eea6b33f197496a9d88be2413beeace1d4ae3eedc4c12d8a5bd7c837e50749a03ac0f0df0243d97641415fadf89c0d5acef63ce87698
-  data.tar.gz: 0b3273dc344198c2e05ca41257b623a6e919c84e219e162a35c3a9a6368fc8ae61f1ecfa828708fad25ec96e7d8a8a95085221331d9169ea35e6eafac7f19379
+  metadata.gz: 506973aa4c9aaaf172e6767b4dfb6668002a65754ee798fa86039d65b45c90e52a93c41a392fa3dac6d0d782bf124bcfef38538ae43bc559349874b0c6105ac3
+  data.tar.gz: adff5451e37aeb001d4b2fd309ee9f8363944e96f887b884f9fcd44b2492136bed4e2148da8033b21a261e078a38ad7e8b62c041efb421082fecf26174fa3508

data/README.md

@@ -13,75 +13,84 @@ This client allows you to connect the MyJohnDeere API without having to code you
 We provide RDoc documentation, but here is a helpful guide for getting started. Because the gem name is long, all examples are going
 to assume this shortcut:
 
-    JD = MyJohnDeereApi
+```ruby
+JD = MyJohnDeereApi
+```
 
 So that when you see:
 
-    JD::Authorize
-
+```ruby
+JD::Authorize
+```
 It really means:
 
-    MyJohnDeereApi::Authorize
-
+```ruby
+MyJohnDeereApi::Authorize
+```
 
 ### Authorizing with John Deere via Auth 1.0
 
 This is the simplest path to authorization, though your user has to jump through an extra hoop of giving you the verification code:
   
-    # Create an authorize object, using your app's API key and secret. You can
-    # pass an environment (`:live` or `:sandbox`), which default to `:live`.
-    authorize = JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox)
-    
-    # Retrieve a valid authorization url from John Deere, where you can send 
-    # your user for authorizing your app to the JD platform.
-    url = authorize.authorize_url
-    
-    # Verify the code given to the user during the authorization process, and
-    # turn this into access credentials for your user.
-    authorize.verify(code)    
+```ruby
+# Create an authorize object, using your app's API key and secret. You can
+# pass an environment (`:live` or `:sandbox`), which default to `:live`.
+authorize = JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox)
+
+# Retrieve a valid authorization url from John Deere, where you can send 
+# your user for authorizing your app to the JD platform.
+url = authorize.authorize_url
+
+# Verify the code given to the user during the authorization process, and
+# turn this into access credentials for your user.
+authorize.verify(code)    
+```
 
 In reality, you will likely need to re-instantiate the authorize object when the user returns, and that works without issue:
 
-    # Create an authorize object, using your app's API key and secret.
-    authorize = JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox)
-    
-    # Retrieve a valid authorization url from John Deere.
-    url = authorize.authorize_url
-    
-    # Queue elevator music while your app serves other users...
-    
-    # Re-create the authorize instance in a different process
-    authorize = JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox)
-    
-    # Proceed as normal
-    authorize.verify(code)
+```ruby
+# Create an authorize object, using your app's API key and secret.
+authorize = JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox)
+
+# Retrieve a valid authorization url from John Deere.
+url = authorize.authorize_url
+
+# Queue elevator music while your app serves other users...
+
+# Re-create the authorize instance in a different process
+authorize = JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox)
+
+# Proceed as normal
+authorize.verify(code)
+```
 
 In a web app, you're prefer that your user doesn't have to copy/paste verification codes. So you can pass in an :oauth_callback url.
 When the user authorizes your app with John Deere, they are redirected to the url you provide, with the paraameter 'oauth_verifier'
 that contains the verification code so the user doesn't have to provide it.
 
-    # Create an authorize object, using your app's API key and secret.
-    authorize = JD::Authorize.new(
-      API_KEY, 
-      API_SECRET, 
-      environment: :sandbox,
-      oauth_callback: 'https://example.com'
-    )
-    
-    # Retrieve a valid authorization url from John Deere.
-    # This will contain the callback url encoded into the
-    # query string for you.
-    url = authorize.authorize_url
-    
-    # Queue elevator music while your app serves other users...
-    
-    # Re-create the authorize instance in a different process.
-    # It's not necessary to re-initialize with the callback url.
-    authorize = JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox)
-    
-    # Inside a Rails controller, you might do this:
-    authorize.verify(params[:oauth_verifier])
+```ruby
+# Create an authorize object, using your app's API key and secret.
+authorize = JD::Authorize.new(
+  API_KEY, 
+  API_SECRET, 
+  environment: :sandbox,
+  oauth_callback: 'https://example.com'
+)
 
+# Retrieve a valid authorization url from John Deere.
+# This will contain the callback url encoded into the
+# query string for you.
+url = authorize.authorize_url
+
+# Queue elevator music while your app serves other users...
+
+# Re-create the authorize instance in a different process.
+# It's not necessary to re-initialize with the callback url.
+authorize = JD::Authorize.new(API_KEY, API_SECRET, environment: :sandbox)
+
+# Inside a Rails controller, you might do this:
+authorize.verify(params[:oauth_verifier])
+```
 
 ### Interacting with the user's John Deere account
 
@@ -89,20 +98,21 @@ After authorization is complete, the `Client` object will provide most of the in
 be used with or without user credentials, because some API calls are specific to your application's relationship
 with John Deere, not your user's. But most interactions will involve user data. Here's how to instantiate a client:
 
-    client = JD::Client.new(
-      # the application's API key
-      API_KEY,
-      
-      # the application's API secret
-      API_SECRET,
-      
-      # the chosen environment (:sandbox or :live)
-      environment: :sandbox,
-      
-      # the user's access credentials
-      access: [ACCESS_TOKEN, ACCESS_SECRET]
-    )
-
+```ruby
+client = JD::Client.new(
+  # the application's API key
+  API_KEY,
+  
+  # the application's API secret
+  API_SECRET,
+  
+  # the chosen environment (:sandbox or :live)
+  environment: :sandbox,
+  
+  # the user's access credentials
+  access: [ACCESS_TOKEN, ACCESS_SECRET]
+)
+```
 
 ### Direct API Requests
 
@@ -115,23 +125,25 @@ to be able to make calls that are not yet fully supported by the client. Or some
 
 GET requests require only a resource path.
 
-    client.get('/organizations')
-    
-    # Abbreviated sample response:
+```ruby
+client.get('/organizations')
+
+# Abbreviated sample response:
+{
+  "links": [...],
+  "total": 1,
+  "values": [
     {
-      "links": [...],
-      "total": 1,
-      "values": [
-        {
-          "@type": "Organization",
-          "name": "ABC Farms",
-          "type": "customer",
-          "member": true,
-          "id": "123123",
-          "links": [...]
-        },
-      ]
-    }
+      "@type": "Organization",
+      "name": "ABC Farms",
+      "type": "customer",
+      "member": true,
+      "id": "123123",
+      "links": [...]
+    },
+  ]
+}
+```
 
 This won't provide any client goodies like pagination or validation, but it does parse the returned JSON.
 
@@ -140,22 +152,24 @@ This won't provide any client goodies like pagination or validation, but it does
 
 POST requests require a resource path, and a hash for the request body. The client will camelize the keys, and convert to JSON.
 
-    client.post(
-     '/organizations/123123/assets',
+```ruby
+client.post(
+ '/organizations/123123/assets',
+ {
+   "title"=>"i like turtles", 
+   "assetCategory"=>"DEVICE", 
+   "assetType"=>"SENSOR", 
+   "assetSubType"=>"ENVIRONMENTAL", 
+   "links"=>[
      {
-       "title"=>"i like turtles", 
-       "assetCategory"=>"DEVICE", 
-       "assetType"=>"SENSOR", 
-       "assetSubType"=>"ENVIRONMENTAL", 
-       "links"=>[
-         {
-           "@type"=>"Link", 
-           "rel"=>"contributionDefinition", 
-           "uri"=>"https://sandboxapi.deere.com/platform/contributionDefinitions/CONTRIBUTION_DEFINITION_ID"
-         }
-        ]
-      }
-    )
+       "@type"=>"Link", 
+       "rel"=>"contributionDefinition", 
+       "uri"=>"https://sandboxapi.deere.com/platform/contributionDefinitions/CONTRIBUTION_DEFINITION_ID"
+     }
+    ]
+  }
+)
+```
 
 John Deere's standard response is a 201 HTTP status code, with the message "Created". This method returns the full Net::HTTP response.
 
@@ -164,22 +178,24 @@ John Deere's standard response is a 201 HTTP status code, with the message "Crea
 
 PUT requests require a resource path, and a hash for the request body. The client will camelize the keys, and convert to JSON.
 
-    client.put(
-     '/assets/123123',
+```ruby
+client.put(
+ '/assets/123123',
+ {
+   "title"=>"i REALLY like turtles", 
+   "assetCategory"=>"DEVICE", 
+   "assetType"=>"SENSOR", 
+   "assetSubType"=>"ENVIRONMENTAL", 
+   "links"=>[
      {
-       "title"=>"i REALLY like turtles", 
-       "assetCategory"=>"DEVICE", 
-       "assetType"=>"SENSOR", 
-       "assetSubType"=>"ENVIRONMENTAL", 
-       "links"=>[
-         {
-           "@type"=>"Link", 
-           "rel"=>"contributionDefinition", 
-           "uri"=>"https://sandboxapi.deere.com/platform/contributionDefinitions/CONTRIBUTION_DEFINITION_ID"
-         }
-        ]
-      }
-    )
+       "@type"=>"Link", 
+       "rel"=>"contributionDefinition", 
+       "uri"=>"https://sandboxapi.deere.com/platform/contributionDefinitions/CONTRIBUTION_DEFINITION_ID"
+     }
+    ]
+  }
+)
+```
 
 John Deere's standard response is a 204 HTTP status code, with the message "No Content". This method returns the full Net::HTTP response.
 
@@ -188,7 +204,9 @@ John Deere's standard response is a 204 HTTP status code, with the message "No C
 
 DELETE requests require only a resource path.
 
-    client.delete('/assets/123123')
+```ruby
+client.delete('/assets/123123')
+```
 
 John Deere's standard response is a 204 HTTP status code, with the message "No Content". This method returns the full Net::HTTP response.
 

data/lib/my_john_deere_api/version.rb

@@ -1,3 +1,3 @@
 module MyJohnDeereApi
-  VERSION='0.15.4'
+  VERSION='0.15.5'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: my_john_deere_api
 version: !ruby/object:Gem::Version
-  version: 0.15.4
+  version: 0.15.5
 platform: ruby
 authors:
 - Jaime Bellmyer