stac 0.1.0 → 0.3.0

data/lib/stac/extensions/scientific_citation.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../extension'
+require_relative '../item'
+require_relative '../collection'
+
+module STAC
+  module Extensions
+    # Utilities for Scientific Citation extension.
+    #
+    # Scientific Citation \Extension Specification: https://github.com/stac-extensions/scientific/
+    module ScientificCitation
+      extend Extension
+
+      identifier 'https://stac-extensions.github.io/scientific/v1.0.0/schema.json'
+      scope STAC::Item, STAC::Collection
+
+      module Properties # rubocop:disable Style/Documentation
+        attr_reader :extra
+
+        def sci_doi
+          extra['sci:doi']
+        end
+
+        def sci_doi=(doi)
+          extra['sci:doi'] = doi
+        end
+
+        def sci_citation
+          extra['sci:citation']
+        end
+
+        def sci_citation=(citation)
+          extra['sci:citation'] = citation
+        end
+
+        def sci_publications
+          extra.fetch('sci:publications', []).map { |hash| Publication.new(hash) }
+        end
+
+        def sci_publications=(publications)
+          extra['sci:publications'] = publications.map(&:to_h)
+        end
+      end
+
+      module Asset
+        include Properties
+      end
+
+      module Collection
+        include Properties
+      end
+
+      # Represents \Publication object of Scientific Citation extension.
+      class Publication
+        attr_reader :raw_hash # :nodoc:
+
+        def initialize(raw_hash)
+          @raw_hash = raw_hash
+        end
+
+        def to_h
+          raw_hash
+        end
+
+        def doi
+          raw_hash['doi']
+        end
+
+        def doi=(doi)
+          raw_hash['doi'] = doi
+        end
+
+        def citation
+          raw_hash['citation']
+        end
+
+        def catation=(citation)
+          raw_hash['citation'] = citation
+        end
+      end
+    end
+  end
+end

data/lib/stac/extensions/view_geometry.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../extension'
+require_relative '../item'
+
+module STAC
+  module Extensions
+    # Utilities for View Geometry extension.
+    #
+    # View Geometry \Extension Specification: https://github.com/stac-extensions/scientific/
+    module ViewGeometry
+      extend Extension
+
+      identifier 'https://stac-extensions.github.io/view/v1.0.0/schema.json'
+      scope STAC::Item
+
+      module Properties # rubocop:disable Style/Documentation
+        attr_reader :extra
+
+        %w[
+          view:off_nadir view:incidence_angle view:azimuth view:sun_azimuth view:sun_elevation
+        ].each do |field|
+          method_name = field.sub(':', '_')
+
+          define_method(method_name) do
+            # @type self: Properties
+            extra[field]
+          end
+
+          define_method("#{method_name}=") do |value|
+            # @type self: Properties
+            extra[field] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stac/extent.rb

@@ -1,18 +1,50 @@
 # frozen_string_literal: true
 
+require_relative 'hash_like'
+
 module STAC
-  # Represents \STAC extent object, which describes the spatio-temporal extents of a Collection.
+  # Represents \STAC extent object, which describes the spatio-temporal extents of a collection.
   #
   # Specification: https://github.com/radiantearth/stac-spec/blob/master/collection-spec/collection-spec.md#extent-object
   class Extent
-    # Describes the spatial extents of a Collection
+    include HashLike
+
+    class << self
+      # Deserializes an Extent from a Hash.
+      def from_hash(hash)
+        transformed = hash.transform_keys(&:to_sym)
+        transformed[:spatial] = Spatial.from_hash(transformed.fetch(:spatial))
+        transformed[:temporal] = Temporal.from_hash(transformed.fetch(:temporal))
+        new(**transformed)
+      end
+    end
+
+    attr_accessor :spatial, :temporal
+
+    def initialize(spatial:, temporal:, **extra)
+      @spatial = spatial
+      @temporal = temporal
+      @extra = extra.transform_keys(&:to_s)
+    end
+
+    # Serializes self to a Hash.
+    def to_h
+      {
+        'spatial' => spatial.to_h,
+        'temporal' => temporal.to_h,
+      }.merge(extra)
+    end
+
+    # Describes the spatial extents of a collection
     class Spatial
+      include HashLike
+
       # Deserializes a Spatial from a Hash.
       def self.from_hash(hash)
         new(**hash.transform_keys(&:to_sym))
       end
 
-      attr_accessor :bbox, :extra
+      attr_accessor :bbox
 
       def initialize(bbox:, **extra)
         @bbox = bbox
@@ -27,14 +59,16 @@ module STAC
       end
     end
 
-    # Describes the temporal extents of a Collection.
+    # Describes the temporal extents of a collection.
     class Temporal
+      include HashLike
+
       # Deserializes a Temporal from a Hash.
       def self.from_hash(hash)
         new(**hash.transform_keys(&:to_sym))
       end
 
-      attr_accessor :interval, :extra
+      attr_accessor :interval
 
       def initialize(interval:, **extra)
         @interval = interval
@@ -48,31 +82,5 @@ module STAC
         }.merge(extra)
       end
     end
-
-    class << self
-      # Deserializes an Extent from a Hash.
-      def from_hash(hash)
-        transformed = hash.transform_keys(&:to_sym)
-        transformed[:spatial] = Spatial.from_hash(transformed.fetch(:spatial))
-        transformed[:temporal] = Temporal.from_hash(transformed.fetch(:temporal))
-        new(**transformed)
-      end
-    end
-
-    attr_accessor :spatial, :temporal, :extra
-
-    def initialize(spatial:, temporal:, **extra)
-      @spatial = spatial
-      @temporal = temporal
-      @extra = extra.transform_keys(&:to_s)
-    end
-
-    # Serializes self to a Hash.
-    def to_h
-      {
-        'spatial' => spatial.to_h,
-        'temporal' => temporal.to_h,
-      }.merge(extra)
-    end
   end
 end

data/lib/stac/file_writer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'json'
+require 'uri'
+require_relative 'errors'
+
+module STAC
+  # Class to write a hash as JSON on a file.
+  class FileWriter
+    def initialize(hash_to_json: ->(hash) { JSON.generate(hash) })
+      @hash_to_json = hash_to_json
+    end
+
+    # Creates a file on `dest` with the given hash as JSON.
+    def write(hash, dest:)
+      dest_uri = URI.parse(dest)
+      path = if dest_uri.relative?
+               dest
+             elsif dest_uri.is_a?(URI::File)
+               dest_uri.path.to_s
+             else
+               raise NotSupportedURISchemeError, "not supported URI scheme: #{dest}"
+             end
+
+      pathname = Pathname(path)
+      pathname.dirname.mkpath
+      pathname.write(@hash_to_json.call(hash))
+    end
+  end
+end

data/lib/stac/hash_like.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module STAC
+  # Enables included class to behave like Hash.
+  module HashLike
+    # Extra fields that do not belong to the STAC core specification.
+    attr_reader :extra
+
+    # When there is an attribute with the given name, returns the attribute value.
+    # Otherwise, calls `extra [key]`.
+    def [](key)
+      if respond_to?(key) && method(key).arity.zero?
+        public_send(key)
+      else
+        extra[key.to_s]
+      end
+    end
+
+    # When there is an attribute writer with the given name, assigns the value to the attribute.
+    # Otherwise, adds the given key-value pair to `extra` hash.
+    def []=(key, value)
+      method = "#{key}="
+      if respond_to?(method)
+        public_send(method, value)
+      else
+        extra[key.to_s] = value
+      end
+    end
+
+    # Sets the attributes (like ActiveModel::AttributeAssignment#assign_attributes)
+    # or merges the args into `extra` hash (like Hash#update).
+    def update(**options)
+      options.each do |key, value|
+        self[key] = value
+      end
+      self
+    end
+
+    def to_hash # :nodoc:
+      to_h
+    end
+
+    # Serializes self to a Hash.
+    def to_h
+      extra
+    end
+
+    # Serializes self to a JSON string.
+    def to_json(...)
+      to_h.to_json(...)
+    end
+
+    # Returns `true` if all of the followings are true:
+    # - the given object is an instance of tha same class
+    # - `self.to_hash == other.to_hash`
+    #
+    # Otherwise, returns `false`.
+    def ==(other)
+      other.instance_of?(self.class) && to_hash == other.to_hash
+    end
+
+    # Returns a copy of self by serializes self to a JSON and desirializes it by `.from_hash`.
+    def deep_dup
+      unless self.class.respond_to?(:from_hash)
+        raise NotImplementedError, "#{self.class} must implement `.from_hash(hash)` to use `HashLike#deep_dup`"
+      end
+
+      hash = JSON.parse(to_json)
+      self.class.from_hash(hash)
+    end
+  end
+end

data/lib/stac/item.rb

@@ -10,25 +10,27 @@ module STAC
   #
   # \STAC \Item Specification: https://github.com/radiantearth/stac-spec/tree/master/item-spec
   class Item < STAC::STACObject
-    self.type = 'Feature'
+    @type = 'Feature'
 
     class << self
       def from_hash(hash)
-        h = hash.dup
-        h['properties'] = Properties.from_hash(h.fetch('properties'))
-        h['assets'] = h.fetch('assets').transform_values { |v| Asset.from_hash(v) }
+        h = hash.transform_keys(&:to_sym)
+        h[:properties] = Properties.from_hash(h.fetch(:properties, {}))
+        h[:assets] = h.fetch(:assets, {}).transform_values { |v| Asset.from_hash(v) }
         super(h)
       rescue KeyError => e
         raise ArgumentError, "required field not found: #{e.key}"
       end
     end
 
-    attr_accessor :geometry, :bbox, :properties, :assets, :collection_id
+    attr_accessor :id, :geometry, :bbox, :collection_id
+
+    attr_reader :properties, :assets
 
     def initialize(
-      id:, geometry:, properties:, links:, assets:, bbox: nil, collection: nil, stac_extensions: nil, **extra
+      id:, geometry:, properties:, links: [], assets: {}, bbox: nil, collection: nil, stac_extensions: [], **extra
     )
-      super(id: id, links: links, stac_extensions: stac_extensions, **extra)
+      @id = id
       @geometry = geometry
       @properties = properties
       @assets = assets
@@ -39,6 +41,16 @@ module STAC
       else
         @collection_id = collection
       end
+      super(links: links, stac_extensions: stac_extensions, **extra)
+    end
+
+    def [](key)
+      value = super
+      if value.nil?
+        properties.extra[key.to_s]
+      else
+        value
+      end
     end
 
     def to_h
@@ -48,6 +60,7 @@ module STAC
         },
       ).merge(
         {
+          'id' => id,
           'bbox' => bbox,
           'properties' => properties.to_h,
           'assets' => assets.transform_values(&:to_h),
@@ -56,11 +69,6 @@ module STAC
       )
     end
 
-    # Returns datetime from #properties.
-    def datetime
-      properties.datetime
-    end
-
     # Returns a rel="collection" link as a collection object if it exists.
     def collection
       link = find_link(rel: 'collection')
@@ -69,17 +77,45 @@ module STAC
 
     # Overwrites rel="collection" link and #collection_id attribute.
     def collection=(collection)
-      raise ArgumentError, 'collection must have a rel="self" link' unless (collection_href = collection.self_href)
-
       @collection_id = collection.id
-      collection_link = Link.new(
-        rel: 'collection',
-        href: collection_href,
-        type: 'application/json',
-        title: collection.title,
-      )
-      remove_link(rel: 'collection')
-      add_link(collection_link)
+      remove_links(rel: 'collection')
+      add_link(collection, rel: 'collection', type: 'application/json', title: collection.title)
+    end
+
+    # Adds an asset with the given key.
+    #
+    # When the item has extendable stac_extensions, make the asset extend the extension modules.
+    def add_asset(key:, href:, title: nil, description: nil, type: nil, roles: nil, **extra)
+      asset = Asset.new(href: href, title: title, description: description, type: type, roles: roles, **extra)
+      extensions.each do |extension|
+        asset.extend(extension::Asset) if extension.const_defined?(:Asset)
+      end
+      assets[key] = asset
+      self
+    end
+
+    private
+
+    def respond_to_missing?(symbol, include_all)
+      if properties.respond_to?(symbol)
+        true
+      else
+        super
+      end
+    end
+
+    def method_missing(symbol, *args, **options, &block)
+      if properties.respond_to?(symbol)
+        properties.public_send(symbol, *args, **options, &block)
+      else
+        super
+      end
+    end
+
+    def apply_extension!(extension)
+      super
+      properties.extend(extension::Properties) if extension.const_defined?(:Properties)
+      assets.each_value { |asset| asset.extend(extension::Asset) } if extension.const_defined?(:Asset)
     end
   end
 end

data/lib/stac/link.rb

@@ -3,10 +3,23 @@
 require 'pathname'
 require 'uri'
 require_relative 'errors'
+require_relative 'hash_like'
 
 module STAC
+  # Raised when a link does not have href or owner.
+  class LinkHrefError < Error
+    attr_reader :link
+
+    def initialize(msg = nil, link:)
+      super(msg)
+      @link = link
+    end
+  end
+
   # Represents \STAC link object, which describes a relationship with another entity.
   class Link
+    include HashLike
+
     class << self
       # Deserializes a Link from a Hash.
       def from_hash(hash)
@@ -14,14 +27,15 @@ module STAC
       end
     end
 
-    attr_accessor :rel, :href, :type, :title, :extra
+    attr_accessor :rel, :type, :title
+
+    attr_writer :href
 
     # Owner object of this link.
     attr_accessor :owner
 
-    attr_writer :resolver # :nodoc:
-
-    def initialize(rel:, href:, type: nil, title: nil, **extra)
+    def initialize(target = nil, rel:, href:, type: nil, title: nil, **extra)
+      @target = target
       @rel = rel
       @href = href
       @type = type
@@ -39,32 +53,54 @@ module STAC
       }.merge(extra).compact
     end
 
+    # Determines if the link's target is a resolved STACObject.
+    def resolved?
+      !@target.nil?
+    end
+
+    def href
+      @href || @target&.self_href
+    end
+
     # Returns the absolute HREF for this link.
-    #
-    # When it could not assemble the absolute HREF, it returns nil.
     def absolute_href
-      if URI(href).absolute?
-        href
+      if URI(href!).absolute?
+        href!
+      elsif (base_href = owner&.self_href)
+        Pathname(base_href).dirname.join(href!).to_s
+      end
+    end
+
+    # Returns the relative HREF for this link.
+    def relative_href
+      if URI(href!).relative?
+        href!
       elsif (base_href = owner&.self_href)
-        Pathname(base_href).dirname.join(href).to_s
+        Pathname(href!).relative_path_from(Pathname(base_href).dirname).to_s
       end
     end
 
     # Returns a \STAC object resolved from HREF.
     #
     # When it could not assemble the absolute HREF, it returns nil.
-    def target
+    def target(http_client: owner&.http_client || STAC.default_http_client)
       @target ||= if (url = absolute_href)
-                    object = resolver.resolve(url)
+                    object = ObjectResolver.new(http_client: http_client).resolve(url)
                     object.self_href = url
                     object
                   end
     end
 
-    private
+    def href! # :nodoc:
+      href or raise LinkHrefError.new('href is nil', link: self)
+    end
+
+    def absolute_href! # :nodoc:
+      absolute_href or raise LinkHrefError.new('could not assemble absolute href', link: self)
+    end
 
-    def resolver
-      @resolver ||= ObjectResolver.new
+    def relative_href! # :nodoc:
+      relative_href or raise LinkHrefError.new('could not assemble relative href', link: self)
     end
   end
 end

data/lib/stac/object_resolver.rb

@@ -3,30 +3,22 @@
 require 'json'
 require_relative 'catalog'
 require_relative 'collection'
-require_relative 'default_http_client'
 require_relative 'errors'
 require_relative 'item'
 
 module STAC
   # Resolves a \STAC object from a URL.
   class ObjectResolver
-    RESOLVABLES = [Catalog, Collection, Item].freeze # :nodoc:
-
     class << self
-      # Sets the default HTTP client.
-      #
-      # HTTP client must implement method `get: (URI uri) -> String,` which fetches the URI resource through HTTP.
-      attr_writer :default_http_client
-
-      # Returns the default HTTP client.
-      def default_http_client
-        @default_http_client ||= DefaultHTTPClient.new
-      end
+      # Resolvable classes. Default is Catalog, Collection and Item.
+      attr_reader :resolvables
     end
 
+    @resolvables = [Catalog, Collection, Item]
+
     attr_reader :http_client
 
-    def initialize(http_client: self.class.default_http_client)
+    def initialize(http_client:)
       @http_client = http_client
     end
 
@@ -38,15 +30,16 @@ module STAC
     # - file
     #
     # Raises:
-    # - STAC::UnknownURISchemeError when a URL with unsupported scheme was given
+    # - STAC::NotSupportedURISchemeError when a URL with not supported scheme was given
     # - STAC::TypeError when it could not resolve any \STAC objects
     def resolve(url)
-      str = read(url)
-      hash = JSON.parse(str)
-      klass = RESOLVABLES.find { |c| c.type == hash['type'] }
+      hash = read(url)
+      klass = self.class.resolvables.find { |c| c.type == hash['type'] }
       raise TypeError, "unknown STAC object type: #{hash['type']}" unless klass
 
-      klass.from_hash(hash)
+      object = klass.from_hash(hash)
+      object.http_client = http_client
+      object
     end
 
     private
@@ -57,9 +50,10 @@ module STAC
       when URI::HTTP
         http_client.get(uri)
       when URI::File
-        File.read(uri.path.to_s)
+        str = File.read(uri.path.to_s)
+        JSON.parse(str)
       else
-        raise UnknownURISchemeError, "unknown URI scheme: #{url}"
+        raise NotSupportedURISchemeError, "not supported URI scheme: #{url}"
       end
     end
   end

data/lib/stac/properties.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
 require 'time'
+require_relative 'common_metadata'
+require_relative 'hash_like'
 
 module STAC
   # Represents \STAC properties object, which is additional metadata for Item.
   #
   # Specification: https://github.com/radiantearth/stac-spec/blob/master/item-spec/item-spec.md#properties-object
   class Properties
+    include HashLike
+    include CommonMetadata
+
     class << self
       # Deserializes a Properties from a Hash.
       def from_hash(hash)
@@ -16,7 +21,7 @@ module STAC
       end
     end
 
-    attr_accessor :datetime, :extra
+    attr_accessor :datetime
 
     def initialize(datetime:, **extra)
       @datetime = datetime

data/lib/stac/provider.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require_relative 'hash_like'
+
 module STAC
   # Represents \STAC provider object, which provides information about a provider.
   #
   # Specicication: https://github.com/radiantearth/stac-spec/blob/master/collection-spec/collection-spec.md#provider-object
   class Provider
+    include HashLike
+
     class << self
       # Deserializes a Provider from a Hash.
       def from_hash(hash)
@@ -12,7 +16,7 @@ module STAC
       end
     end
 
-    attr_accessor :name, :description, :roles, :url, :extra
+    attr_accessor :name, :description, :roles, :url
 
     def initialize(name:, description: nil, roles: nil, url: nil, **extra)
       @name = name