stac 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2627d9a703e290a75afaa175182cffdb596a75e64219d5078b609747606edc7
-  data.tar.gz: b9fbc61200079233af6e820faaee550bb9eb3bf98cb5a4e30536342e6ac932fd
+  metadata.gz: 63e6934e16a8ff0f70fb3e7c9770d84b2a69b423b2ec00e21a217562a1a22438
+  data.tar.gz: 92dba6bb4fe3ce5a8952cd7b9a5ef3de35d7accf9d35ca7a10469b62596e6b5d
 SHA512:
-  metadata.gz: f2ea9eff6cfa3171f1a96ec8973184fd361226d7e6afaefd28d9e96286a4991f7c3e3968f5baa69b49330e98229bd927b53d70e1a2613f52dddbc7d9d12358a5
-  data.tar.gz: 3c556bac6620eef51f7756087a507236dd35cf97906751044d630df9d18c94faf20333d15c24f3d93e81c7fd417b9d0d0bf5ab8ab61464deb1fd786030481eec
+  metadata.gz: cd77e8737745c7cbe084fb43f654db060605891385d3494a263523e16d997a9a96913d4bd72fcee488036102c6dc98595fbb9973a04138f066531ca351095705
+  data.tar.gz: efe10bba8bc91a59b74ee5b04b2d5f0d1cee86d7b47c49c920ffb456b48b32770fa436d2cf756b076986245fc720143e9c6304016008d9bfdcdbf0f62602cb64

data/.rubocop.yml

@@ -9,6 +9,9 @@ AllCops:
 Style/GuardClause:
   Enabled: false
 
+Style/NumericLiterals:
+  Enabled: false
+
 Style/TrailingCommaInArguments:
   EnforcedStyleForMultiline: consistent_comma
 

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.3.0] - 2022-12-16
+
+- Add extension modules from the current stable extensions (`ElectroOptical`, `Projection`, `ScientificCitation` and `ViewGeometry`).
+- Make `STACObject` extend extension modules from `stac_extensions` value automatically.
+- Introduce `HashLike` module and make STAC Object classes include it.
+- Fix a bug that `Catalog#all_items` returns only direct children's items.
+- Improve documentation.
+- Add methods `#add_child` and `#add_item` to `STAC::Catalog`
+- Add `STAC::Catalog#export`
+
 ## [0.2.0] - 2022-11-02
 
 - Add `STAC::CommonMetadata` and make `Asset` and `Properties` include it.

data/GETTING_STARTED.md

@@ -0,0 +1,384 @@
+# Getting Started
+
+- [Reading STAC Objects](#reading-stac-objects)
+- [STAC Object Classes](#stac-object-classes)
+  - [STAC::Catalog](#staccatalog)
+    - [Crawling Catalog Links](#crawling-catalog-links)
+    - [Exporting Catalog](#exporting-catalog)
+  - [STAC::Collection](#staccollection)
+  - [STAC::Item](#stacitem)
+    - [Common Metadata](#common-metadata)
+- [Extensions](#extensions)
+  - [Adding Extensions](#adding-extensions)
+- [Using Custom HTTP Client](#using-custom-http-client)
+
+## Reading STAC Objects
+
+You can read any STAC objects from URL by `STAC.from_url`:
+
+```ruby
+catalog = STAC.from_url('https://raw.githubusercontent.com/radiantearth/stac-spec/master/examples/catalog.json')
+catalog.class #=> STAC::Catalog
+catalog.type #=> "Catalog"
+
+collection = STAC.from_url('https://raw.githubusercontent.com/radiantearth/stac-spec/master/examples/collection.json')
+collection.class #=> STAC::Collection
+collection.type #=> "Collection"
+
+item = STAC.from_item('https://raw.githubusercontent.com/radiantearth/stac-spec/master/examples/core-item.json')
+item.class #=> STAC::Item
+item.type #=> "Feature"
+```
+
+Also, from a local file by `STAC.from_file`:
+
+```ruby
+catalog = STAC.from_file('/path/to/local/catalog.json')
+collection = STAC.from_file('/path/to/local/collection.json')
+item = STAC.from_file('/path/to/local/item.json')
+```
+
+## STAC Object Classes
+
+There are 3 core STAC object classes: `STAC::Catalog`, `STAC::Collection`, and `STAC::Item`.
+
+They have a class method `from_hash(hash)`, which returns its instance converted from the given Hash.
+
+```ruby
+catalog = STAC::Catalog.from_hash(
+  {
+    'stac_version' => '1.0.0',
+    'type' => 'Catalog',
+    'id' => '20201211_223832_CS2',
+    'description' => 'A simple catalog example',
+    'links' => [],
+  }
+)
+```
+
+And they have the following instance methods in common:
+
+- `extra: -> Hash[String, untyped]` returns extra fields that do not belong to the core specification like STAC extensions fields
+- `to_h: -> Hash[String, untyped]`
+- `to_json: -> String`
+- `deep_dup: -> self` returns a deep copy of self.
+- `stac_extensions: -> Array[String]`
+- `add_extension: (String extension_id) -> self | (Module extension) -> self` (see [Extensions](#extensions))
+- `links: -> Array[STAC::Link]`
+- `find_link: (rel: String, ?type: String?) -> STAC::Link?`
+- `add_link: (rel: String, href: String, ?type: String?, ?title: String?) -> self`
+
+Followings are shorthand methods for core links:
+
+- `self_href: -> String?` returns rel="self" link's href value
+- `self_href=: (String absolute_href) -> void` adds rel="self" link with the given href
+- `root: -> Catalog?` returns rel="root" link as a catalog object
+- `root=: (Catalog? catalog) -> void` overwrites rel="root" link
+- `parent: -> Catalog?` returns rel="parent" link as a catalog object
+- `parent=: (Catalog? catalog) -> void` overwrites rel="parent" link
+
+### STAC::Catalog
+
+`STAC::Catalog` has the following attributes:
+
+- `attr_accessor id: String`
+- `attr_accessor description: String`
+- `attr_accessor title: String?`
+
+```ruby
+catalog.id = 'awesome_catalog'
+catalog.id #=> "awesome_catalog"
+```
+
+See [STAC Catalog Specification](https://github.com/radiantearth/stac-spec/blob/master/catalog-spec/catalog-spec.md) for the details.
+
+#### Crawling Catalog Links
+
+`STAC::Catalog` also has methods to crawl its `links`:
+
+- `children: -> Enumerator::Lazy[STAC::Catalog, void]` returns catalog/collection objects from rel="child" links
+- `collections: -> Enumerator::Lazy[STAC::Collection, void]` filters only collections from #children
+- `all_collections: -> Enumerator::Lazy[STAC::Collection, void]` returns all collections from the catalog and its children recursively
+- `items: -> Enumerator::Lazy[STAC::Item, void]` returns item objects from rel="items" links
+- `all_items: -> Enumerator::Lazy[STAC::Item, void]` returns all items from the catalog and its children recursively
+- `find_child: (String id, ?recursive: bool) -> STAC::Catalog?`
+- `find_item: (String id, ?recursive: bool) -> STAC::Item?`
+
+Note that the first 5 methods return [`Enumerator::Lazy`](https://rubyapi.org/3.1/o/enumerator/lazy).
+This is to prevent making a large number of HTTP requests when calling the methods.
+
+```ruby
+catalog.collections.each do |collection|
+  puts collection.id
+end
+collection = catalog.find_child('awesome_collection')
+
+catalog.all_items.first(100).each do |item|
+  puts item.id
+end
+item = catalog.find_item('awesome_item', recursive: true)
+```
+
+#### Exporting Catalog
+
+Furthermore, `STAC::Catalog` has methods to create a new static STAC catalog:
+
+- `add_child: (Catalog catalog, ?href: String, ?title: String?) -> self`
+- `add_item: (Item item, ?href: String, ?title: String?) -> self`
+- `export: (?String? dest_dir) -> void`
+
+```ruby
+catalog = STAC::Catalog.new(id: 'root', description: 'The root catalog')
+catalog.self_href = 'https://example.com/catalog.json'
+catalog.root = catalog
+
+item = STAC::Item.from_hash(
+  {
+    'stac_version' => '1.0.0',
+    'type' => 'Feature',
+    'id' => 'item',
+    'geometry' => nil,
+    'properties' => {
+      'datetime' => Time.now.iso8601
+    },
+    'links' => [],
+    'assets' => {}
+  }
+)
+
+# Add rel="item" link to catalog with href="#{item.id}.json" (based on best practice).
+# And add rel="self", rel="root", and rel="parent" links to item.
+catalog.add_item(item)
+
+item.links.each { |l| puts "#{l.rel}: #{l.href}" }
+# self: https://example.com/item.json
+# root: https://example.com/catalog.json
+# parent: https://example.com/catalog.json
+
+sub_catalog = STAC::Catalog.new(id: 'sub-catalog', description: 'The sub catalog')
+
+# Add rel="child" link to catalog with href="#{catalog.id}/catalog.json".
+# Also add rel="self", rel="root", and rel="parent" links to sub-catalog.
+catalog.add_child(sub_catalog)
+
+sub_catalog.add_item(item.deep_dup.update(id: 'sub-item'))
+sub_catalog.links.each { |l| puts "#{l.rel}: #{l.href}" }
+# self: https://example.com/sub-catalog/catalog.json
+# root: https://example.com/catalog.json
+# parent: https://example.com/catalog.json
+# item: https://example.com/sub-catalog/sub-item.json
+
+catalog.links.each { |l| puts "#{l.rel}: #{l.href}" }
+# self: https://example.com/catalog.json
+# root: https://example.com/catalog.json
+# item: https://example.com/item.json
+# child: https://example.com/sub-catalog/catalog.json
+
+# Exports the catalog and its children/item recursively to the given directory.
+catalog.export('path/to/dest')
+
+# $ tree path/to/dest
+# path/to/dest
+# ├── catalog.json
+# ├── item.json
+# └── sub-catalog
+#     ├── catalog.json
+#     └── sub-item.json
+```
+
+### STAC::Collection
+
+`STAC::Collection` inherits `STAC::Catalog`.
+
+The followings are `STAC::Collection` specific attributes:
+
+- `attr_accessor license: String`
+- `attr_accessor extent: STAC::Extent`
+- `attr_accessor keywords: Array[String]?`
+- `attr_accessor providers: Array[STAC::Provider]?`
+- `attr_accessor summaries: Hash[String, untyped]?`
+- `attr_reader assets: Hash[String, STAC::Asset]?`
+
+To add an asset, use:
+
+- `add_asset: (key: String, href: String, ?title: String?, ?description: String?, ?type: String?, ?roles: Array[String]?) -> self`
+
+`STAC::Extent`, `STAC::Provider`, and `STAC::Asset` provide accessors for the corresponding object's fields.
+
+```ruby
+collection.extent.spatial.bbox = [-180, -90, 180, 90]
+collection.extent.spatial.bbox #=> [-180, -90, 180, 90]
+collection.extent.temporal.interval = ['2022-12-01T00:00:00Z', null]
+collection.extent.temporal.interval #=> ["2022-12-01T00:00:00Z", null]
+
+collection.providers << STAC::Provider.new(name: 'sankichi92')
+collection.providers.last.name #=> "sankichi92"
+```
+
+See [STAC Collection Specification](https://github.com/radiantearth/stac-spec/blob/master/collection-spec/collection-spec.md) for the details.
+
+### STAC::Item
+
+`STAC::Item` has the following attributes:
+
+- `attr_accessor id: String`
+- `attr_reader properties: STAC::Properties`
+- `attr_reader assets: Hash[String, STAC::Asset]`
+- `attr_accessor geometry: Hash[String, untyped]?`
+- `attr_accessor bbox: Array[Numeric]?`
+- `attr_accessor collection_id: String?`
+
+And has the following methods:
+
+- `add_asset: (key: String, href: String, ?title: String?, ?description: String?, ?type: String?, ?roles: Array[String]?) -> self`
+- `collection: -> Collection?` returns a rel="collection" link as a collection object
+- `collection=: (Collection collection) -> void` overwrites rel="collection" link and collection_id attribute
+
+See [STAC Item Specification](https://github.com/radiantearth/stac-spec/blob/master/collection-spec/collection-spec.md) for the details.
+
+#### Common Metadata
+
+`STAC::Properties` and `STAC::Asset` includes `STAC::CommonMetadata`, which provides read/write methods for [STAC Common Metadata](https://github.com/radiantearth/stac-spec/blob/master/item-spec/common-metadata.md) fields:
+
+- `title: -> String?`
+- `title=: (String) -> void`
+- `description: -> String?`
+- `description=: (String) -> void`
+- `created: -> Time?`
+- `created=: (Time | String) -> void`
+- `updated: -> Time?`
+- `updated=: (Time | String) -> void`
+- `start_datetime: -> Time?`
+- `start_datetime=: (Time | String) -> void`
+- `end_datetime: -> Time?`
+- `end_datetime=: (Time | String) -> void`
+- `datetime_range: -> Range[Time]?` returns a range from #start_datetime to #end_datetime
+- `datetime_range=: (Range[Time]) -> void` sets #start_datetime and #end_datetime by the given range
+- `license: -> String?`
+- `license=: (String) -> void`
+- `providers: -> Array[Provider]`
+- `providers=: (Array[Provider | Hash[String, untyped]]) -> void`
+- `platform: -> String?`
+- `platform=: (String) -> void`
+- `instruments: -> Array[String]?`
+- `instruments=: (Array[String]) -> void`
+- `constellation: -> String?`
+- `constellation=: (String) -> void`
+- `mission: -> String?`
+- `mission=: (String) -> void`
+- `gsd: -> Numeric`
+- `gsd=: (Numeric) -> void`
+
+These methods are shorthand accessors of `#extra` hash:
+
+```ruby
+item.properties.extra #=> {}
+item.properties.title = 'Awesome Item' # same as `item.properties.extra['title'] = 'Awesome Item'`
+item.properties.title #=> "Awesome Item"
+item.properties.extra #=> {"title"=>"Awesome Item"}
+```
+
+## Extensions
+
+When an extension is added to a STAC object, methods corresponding to the extension will be added **dynamically** by [`Object#extend`](https://rubyapi.org/3.1/o/object#method-i-extend).
+
+These methods are also shorthand accessors of `extra` hash same as `STAC::CommonMetadata`.
+
+```ruby
+item.stac_extensions #=> []
+item.properties.extra #=> {}
+item.properties.eo_cloud_cover #=> raises NoMethodError
+
+item.add_extension('https://stac-extensions.github.io/eo/v1.0.0/schema.json')
+# same as `item.add_extension(STAC::Extensions::ElectroOptical)`
+
+item.stac_extensions #=> ["https://stac-extensions.github.io/eo/v1.0.0/schema.json"]
+item.properties.eo_cloud_cover = 1.2
+item.properties.eo_cloud_cover #=> 1.2
+item.properties.extra #=> {"eo:cloud_cover"=>1.2}
+
+# item.properties extends STAC::Extensions::ElectroOptical::Properties
+item.properties.is_a?(STAC::Extensions::ElectroOptical::Properties) #=> true
+```
+
+Currently, only 4 stable extensions have been implemented:
+
+```ruby
+puts STAC::STACObject.extendables
+# STAC::Extensions::ElectroOptical
+# STAC::Extensions::Projection
+# STAC::Extensions::ScientificCitation
+# STAC::Extensions::ViewGeometry
+```
+
+### Adding Extensions
+
+You can add custom extensions.
+
+Extension modules must extend `STAC::Extension` and set `identifier` and `scope`.
+And you must register it by `STAC::STACObject.add_extendable(extension_module)`.
+
+```ruby
+module MyExtension
+  extend STAC::Extension
+
+  identifier 'https://sankichi92.github.io/my_extension/v1.0.0/schema.json'
+  scope STAC::Item, STAC::Collection
+end
+
+STAC::STACObject.add_extendable(MyExtension)
+```
+
+Then you can add methods to `STAC::Properties`, `STAC::Asset`, and `STAC::Collection` by defining modules with corresponding names **under the extension namespace**:
+
+```ruby
+module MyExtension
+  module Properties
+    def my_field
+      extra['my:field']
+    end
+
+    def my_field(val)
+      extra['my:field'] = val
+    end
+  end
+
+  module Asset
+    include Properties
+  end
+end
+```
+
+See [`lib/stac/extensions`](https://github.com/sankichi92/stac-ruby/tree/main/lib/stac/extensions) for examples.
+
+## Using Custom HTTP Client
+
+Custom HTTP client class must implement `get: (URI | String url) -> Hash[String, untyped]`, which returns response JSON as a Hash:
+
+```ruby
+class MyHTTPClient
+  def get(url)
+    # ...
+  end
+end
+```
+
+You can pass the custom HTTP client to `STAC.from_url` for a specific STAC object instance:
+
+```ruby
+catalog = STAC.from_url('https://example.com/catalog.json', http_client: MyHTTPClient.new)
+```
+
+Or you can set it as the global default by `STAC.default_http_client=`:
+
+```ruby
+STAC.default_http_client = MyHTTPClient.new
+```
+
+If you want to only add custom HTTP headers, you can use `STAC::SimpleHTTPClient`:
+
+```ruby
+http_client = STAC::SimpleHTTPClient.new({ 'X-Foo' => 'Bar' })
+catalog = STAC.from_url('https://example.com/catalog.json', http_client:)
+STAC.default_http_client = http_client
+```

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stac (0.2.0)
+    stac (0.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -17,84 +17,95 @@ GEM
     concurrent-ruby (1.1.10)
     crack (0.4.5)
       rexml
-    debug (1.6.2)
-      irb (>= 1.3.6)
+    csv (3.2.6)
+    debug (1.7.0)
+      irb (>= 1.5.0)
       reline (>= 0.3.1)
     diff-lcs (1.5.0)
     ffi (1.15.5)
+    fileutils (1.7.0)
     hashdiff (1.0.1)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    io-console (0.5.11)
-    irb (1.4.2)
+    io-console (0.6.0)
+    irb (1.6.1)
       reline (>= 0.3.0)
-    json (2.6.2)
-    language_server-protocol (3.17.0.1)
+    json (2.6.3)
+    language_server-protocol (3.17.0.2)
     listen (3.7.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
+    logger (1.5.3)
     minitest (5.16.3)
     parallel (1.22.1)
-    parser (3.1.2.1)
+    parser (3.1.3.0)
       ast (~> 2.4.1)
-    prettier_print (0.1.0)
-    public_suffix (5.0.0)
+    prettier_print (1.1.0)
+    public_suffix (5.0.1)
     rainbow (3.1.1)
     rake (13.0.6)
     rb-fsevent (0.11.2)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (2.6.0)
-    regexp_parser (2.6.0)
-    reline (0.3.1)
+    rbs (2.8.1)
+    regexp_parser (2.6.1)
+    reline (0.3.2)
       io-console (~> 0.5)
     rexml (3.2.5)
-    rspec (3.11.0)
-      rspec-core (~> 3.11.0)
-      rspec-expectations (~> 3.11.0)
-      rspec-mocks (~> 3.11.0)
-    rspec-core (3.11.0)
-      rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.1)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.1)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-support (3.11.1)
-    rubocop (1.36.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.40.0)
       json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.1.2.1)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.20.1, < 2.0)
+      rubocop-ast (>= 1.23.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.21.0)
+    rubocop-ast (1.24.0)
       parser (>= 3.1.1.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
-    rubocop-rspec (2.13.2)
+    rubocop-rspec (2.16.0)
       rubocop (~> 1.33)
-    ruby-lsp (0.3.3)
+    ruby-lsp (0.3.7)
       language_server-protocol (~> 3.17.0)
       sorbet-runtime
-      syntax_tree (>= 3.4)
+      syntax_tree (>= 4.0.2, < 5.0.0)
     ruby-progressbar (1.11.0)
-    sorbet-runtime (0.5.10479)
-    steep (1.1.1)
+    securerandom (0.2.2)
+    sorbet-runtime (0.5.10594)
+    steep (1.3.0)
       activesupport (>= 5.1)
+      csv (>= 3.0.9)
+      fileutils (>= 1.1.0)
+      json (>= 2.1.0)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)
+      logger (>= 1.3.0)
       parallel (>= 1.0.0)
       parser (>= 3.1)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (>= 2.3.2)
+      rbs (>= 2.8.0)
+      securerandom (>= 0.1)
+      strscan (>= 1.0.0)
       terminal-table (>= 2, < 4)
-    syntax_tree (3.6.2)
-      prettier_print
+    strscan (3.0.5)
+    syntax_tree (4.3.0)
+      prettier_print (>= 1.0.2)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
     tzinfo (2.0.5)
@@ -106,7 +117,7 @@ GEM
       hashdiff (>= 0.4.0, < 2.0.0)
 
 PLATFORMS
-  x86_64-darwin-21
+  x86_64-darwin-22
   x86_64-linux
 
 DEPENDENCIES
@@ -123,4 +134,4 @@ DEPENDENCIES
   webmock
 
 BUNDLED WITH
-   2.3.24
+   2.3.26

data/README.md

@@ -5,6 +5,17 @@ See [satc-client-ruby](https://github.com/sankichi92/stac-client-ruby) for [STAC
 
 This gem's implementation refers to [PySTAC](https://github.com/stac-utils/pystac).
 
+### STAC Spec Version Support
+
+v1.0.0
+
+### STAC Extensions Support
+
+- [Electro-Optical](https://github.com/stac-extensions/eo) v1.0.0
+- [Projection](https://github.com/stac-extensions/projection) v1.0.0
+- [Scientific Citation](https://github.com/stac-extensions/scientific) v1.0.0
+- [View Geometry](https://github.com/stac-extensions/view) v1.0.0
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -17,65 +28,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Getting Started
 
-```ruby
-require 'stac'
-
-# Reading a Catalog
-# ================
-
-# Read the example catalog.
-catalog = STAC.from_url('https://raw.githubusercontent.com/radiantearth/stac-spec/master/examples/catalog.json')
-
-# Print some basic metadata.
-puts "ID: #{catalog.id}"
-puts "Title: #{catalog.title}"
-puts "Description: #{catalog.description}"
-
-# Crawling Child Catalogs/Collections
-# ================
-
-# List Collections in the Catalog.
-puts 'Collections IDs:'
-catalog.collections.each do |collection|
-  puts "- #{collection.id}"
-end
-
-# Get a child Catalog or Collection by ID.
-_collection = catalog.find_child('extensions-collection')
-
-# Crawling Items
-# ================
-
-# List all items associated with the Catalog recursively.
-puts 'Item IDs:'
-catalog.all_items.each do |item|
-  puts "- #{item.id}"
-end
-
-# Item Metadata
-# ================
-
-# Get an Item by ID.
-item = catalog.find_item('CS3-20160503_132131_08')
-
-# Print core Item metadeata.
-puts 'geometry:'
-p item.geometry
-puts 'bbox:'
-p item.bbox
-puts 'datetime:'
-p item.datetime
-puts 'collection_id:'
-p item.collection_id
-
-# Get actual Collection instance instead of ID.
-_collection = item.collection
-
-# Print common metadata.
-puts "instruments: #{item.properties.instruments}"
-puts "platform: #{item.properties.platform}"
-puts "gsd: #{item.properties.gsd}"
-```
+[GETTING_STARTED.md](GETTING_STARTED.md)
 
 ## Documentation