dato 0.7.18 → 0.8.2

data/lib/dato/dump/operation/add_to_data_file.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dato/dump/format'
+require "dato/dump/format"
 
 module Dato
   module Dump
@@ -24,15 +24,15 @@ module Dato
           old_content = if File.exist? complete_path
                           ::File.read(complete_path)
                         else
-                          ''
+                          ""
                         end
 
           new_content = old_content.sub(
             /\n*(#\s*datocms:start.*#\s*datocms:end|\Z)/m,
-            "\n\n# datocms:start\n#{content_to_add}\n# datocms:end"
+            "\n\n# datocms:start\n#{content_to_add}\n# datocms:end",
           )
 
-          File.open(complete_path, 'w') do |f|
+          File.open(complete_path, "w") do |f|
             f.write new_content
           end
         end

data/lib/dato/dump/operation/create_data_file.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'fileutils'
-require 'dato/dump/format'
+require "fileutils"
+require "dato/dump/format"
 
 module Dato
   module Dump
@@ -19,7 +19,7 @@ module Dato
         def perform
           FileUtils.mkdir_p(File.dirname(path))
 
-          File.open(File.join(context.path, path), 'w') do |file|
+          File.open(File.join(context.path, path), "w") do |file|
             file.write Format.dump(format, value)
           end
         end

data/lib/dato/dump/operation/create_post.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'fileutils'
-require 'dato/dump/format'
+require "fileutils"
+require "dato/dump/format"
 
 module Dato
   module Dump
@@ -9,8 +9,7 @@ module Dato
       class CreatePost
         attr_reader :context, :path
 
-        attr_accessor :frontmatter_format, :frontmatter_value
-        attr_accessor :content
+        attr_accessor :frontmatter_format, :frontmatter_value, :content
 
         def initialize(context, path)
           @context = context
@@ -20,10 +19,10 @@ module Dato
         def perform
           FileUtils.mkdir_p(File.dirname(path))
 
-          File.open(File.join(context.path, path), 'w') do |file|
+          File.open(File.join(context.path, path), "w") do |file|
             file.write Format.frontmatter_dump(
               frontmatter_format,
-              frontmatter_value
+              frontmatter_value,
             )
             file.write "\n\n"
             file.write content

data/lib/dato/dump/operation/directory.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'fileutils'
+require "fileutils"
 
 module Dato
   module Dump

data/lib/dato/dump/runner.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'dato/dump/dsl/root'
-require 'dato/dump/operation/root'
-require 'dato/dump/ssg_detector'
-require 'dato/local/loader'
+require "dato/dump/dsl/root"
+require "dato/dump/operation/root"
+require "dato/dump/ssg_detector"
+require "dato/local/loader"
 
 module Dato
   module Dump
@@ -25,7 +25,7 @@ module Dato
         Dsl::Root.new(
           File.read(config_path),
           loader.items_repo,
-          operation
+          operation,
         )
 
         operation.perform

data/lib/dato/dump/ssg_detector.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'toml'
-require 'json'
-require 'yaml'
+require "toml"
+require "json"
+require "yaml"
 
 module Dato
   module Dump
@@ -18,17 +18,17 @@ module Dato
 
       HUGO = [
         {
-          file: 'config.toml',
-          loader: ->(content) { TOML::Parser.new(content).parsed }
+          file: "config.toml",
+          loader: ->(content) { TOML::Parser.new(content).parsed },
         },
         {
-          file: 'config.yaml',
-          loader: ->(content) { YAML.safe_load(content) }
+          file: "config.yaml",
+          loader: ->(content) { YAML.safe_load(content) },
         },
         {
-          file: 'config.json',
-          loader: ->(content) { JSON.parse(content) }
-        }
+          file: "config.json",
+          loader: ->(content) { JSON.parse(content) },
+        },
       ].freeze
 
       def initialize(path)
@@ -40,13 +40,13 @@ module Dato
           node_generator ||
           python_generator ||
           hugo ||
-          'unknown'
+          "unknown"
       end
 
       private
 
       def ruby_generator
-        gemfile_path = File.join(path, 'Gemfile')
+        gemfile_path = File.join(path, "Gemfile")
         return unless File.exist?(gemfile_path)
 
         gemfile = File.read(gemfile_path)
@@ -57,13 +57,13 @@ module Dato
       end
 
       def node_generator
-        package_path = File.join(path, 'package.json')
+        package_path = File.join(path, "package.json")
         return unless File.exist?(package_path)
 
         package = JSON.parse(File.read(package_path))
 
-        deps = package.fetch('dependencies', {})
-        dev_deps = package.fetch('devDependencies', {})
+        deps = package.fetch("dependencies", {})
+        dev_deps = package.fetch("devDependencies", {})
         all_deps = deps.merge(dev_deps)
 
         NODE.find do |generator|
@@ -74,7 +74,7 @@ module Dato
       end
 
       def python_generator
-        requirements_path = File.join(path, 'requirements.txt')
+        requirements_path = File.join(path, "requirements.txt")
         return unless File.exist?(requirements_path)
 
         requirements = File.read(requirements_path)
@@ -89,13 +89,11 @@ module Dato
           config_path = File.join(path, option[:file])
           if File.exist?(config_path)
             config = option[:loader].call(File.read(config_path))
-            config.key? 'baseurl'
+            config.key? "baseurl"
           end
-        end && 'hugo'
+        end && "hugo"
       rescue JSON::ParserError
         nil
-      rescue Psych::SyntaxError
-        nil
       end
     end
   end

data/lib/dato/json_api_deserializer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'dato/json_schema_relationships'
+
+require "dato/json_schema_relationships"
 
 module Dato
   class JsonApiDeserializer
@@ -28,21 +29,19 @@ module Dato
 
       if data[:relationships]
         relationships.each do |relationship, meta|
-          if data[:relationships][relationship]
-            rel_data = data[:relationships][relationship][:data]
-
-            result[relationship] = if meta[:types].length > 1
-                                     rel_data
-                                   else
-                                     if !rel_data
-                                       nil
-                                     elsif meta[:collection]
-                                       rel_data.map { |ref| ref[:id] }
-                                     else
-                                       rel_data[:id]
-                                     end
-                                   end
-          end
+          next unless data[:relationships][relationship]
+
+          rel_data = data[:relationships][relationship][:data]
+
+          result[relationship] = if meta[:types].length > 1
+                                   rel_data
+                                 elsif !rel_data
+                                   nil
+                                 elsif meta[:collection]
+                                   rel_data.map { |ref| ref[:id] }
+                                 else
+                                   rel_data[:id]
+                                 end
         end
       end
 

data/lib/dato/json_api_serializer.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
-require 'dato/json_schema_relationships'
+
+require "dato/json_schema_relationships"
+require "dato/json_schema_type"
 
 module Dato
   class JsonApiSerializer
     attr_reader :link, :type
 
-    def initialize(type, link)
+    def initialize(type: nil, link: nil)
       @link = link
-      @type = type
+      @type = type || type_from_schema
     end
 
     def serialize(resource, id = nil)
@@ -16,19 +18,22 @@ module Dato
 
       data[:id] = id || resource[:id] if id || resource[:id]
 
-      if resource.has_key?(:meta)
-        resource.delete(:meta)
-      end
+      resource.delete(:meta) if resource.key?(:meta)
 
       data[:type] = type
-      data[:attributes] = serialized_attributes(resource)
 
-      serialized_relationships = serialized_relationships(resource)
+      if link.schema &&
+         link.schema.properties["data"] &&
+         link.schema.properties["data"].properties.keys.include?("attributes")
 
-      if serialized_relationships
-        data[:relationships] = serialized_relationships
+        serialized_resource_attributes = serialized_attributes(resource)
+        data[:attributes] = serialized_resource_attributes
       end
 
+      serialized_relationships = serialized_relationships(resource)
+
+      data[:relationships] = serialized_relationships if serialized_relationships
+
       { data: data }
     end
 
@@ -61,18 +66,18 @@ module Dato
                        value.symbolize_keys
                      end
                    else
-                     type = meta[:types].first
+                     meta_type = meta[:types].first
                      if meta[:collection]
                        value.map do |id|
                          {
-                           type: type,
-                           id: id.to_s
+                           type: meta_type,
+                           id: id.to_s,
                          }
                        end
                      else
                        {
-                         type: type,
-                         id: value.to_s
+                         type: meta_type,
+                         id: value.to_s,
                        }
                      end
                    end
@@ -88,21 +93,23 @@ module Dato
     end
 
     def attributes(resource)
-      if type == 'item'
-        return resource.keys.map(&:to_sym) - %i[
-          item_type
-          id
-          created_at
-          updated_at
-          creator
-        ]
+      if type == "item"
+        return resource.keys.reject do |key|
+          %i[
+            item_type
+            id
+            created_at
+            updated_at
+            creator
+          ].include?(key.to_sym)
+        end
       end
 
-      link_attributes['properties'].keys.map(&:to_sym)
+      link_attributes["properties"].keys.map(&:to_sym)
     end
 
     def required_attributes
-      return [] if type == 'item'
+      return [] if type == "item"
 
       (link_attributes.required || []).map(&:to_sym)
     end
@@ -112,7 +119,7 @@ module Dato
     end
 
     def required_relationships
-      if link.schema.properties['data'].required.include?("relationships")
+      if link.schema.properties["data"].required.include?("relationships")
         (link_relationships.required || []).map(&:to_sym)
       else
         []
@@ -120,11 +127,15 @@ module Dato
     end
 
     def link_attributes
-      link.schema.properties['data'].properties['attributes']
+      link.schema.properties["data"].properties["attributes"]
     end
 
     def link_relationships
-      link.schema.properties['data'].properties['relationships']
+      link.schema.properties["data"].properties["relationships"]
+    end
+
+    def type_from_schema
+      Dato::JsonSchemaType.new(link.schema).call
     end
   end
 end

data/lib/dato/json_schema_relationships.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dato
   class JsonSchemaRelationships
     attr_reader :schema
@@ -7,46 +9,40 @@ module Dato
     end
 
     def relationships
-      if !schema || !schema.properties['data']
-        return {}
-      end
+      return {} if !schema || !schema.properties["data"]
 
-      entity = if schema.properties['data'].type.first == 'array'
-                 schema.properties['data'].items
+      entity = if schema.properties["data"].type.first == "array"
+                 schema.properties["data"].items
                else
-                 schema.properties['data']
+                 schema.properties["data"]
                end
 
-      if !entity || !entity.properties['relationships'] || !entity.properties['relationships']
-        return {}
-      end
+      return {} if !entity || !entity.properties["relationships"] || !entity.properties["relationships"]
 
-      relationships = entity.properties['relationships'].properties
+      relationships = entity.properties["relationships"].properties
 
       relationships.each_with_object({}) do |(relationship, schema), acc|
-        is_collection = schema.properties['data'].type.first == 'array'
+        is_collection = schema.properties["data"].type.first == "array"
 
         types = if is_collection
-                       [type(schema.properties['data'].items)]
-                     elsif schema.properties['data'].type.first == 'object'
-                       [type(schema.properties['data'])]
-                     else
-                       schema.properties['data'].any_of.map do |option|
-                         type(option)
-                       end.compact
-                     end
+                  [type(schema.properties["data"].items)]
+                elsif schema.properties["data"].type.first == "object"
+                  [type(schema.properties["data"])]
+                else
+                  schema.properties["data"].any_of.map do |option|
+                    type(option)
+                  end.compact
+                end
 
         acc[relationship.to_sym] = {
           collection: is_collection,
-          types: types
+          types: types,
         }
       end
     end
 
     def type(definition)
-      if definition.properties['type']
-        definition.properties['type'].pattern.source.gsub(/(^\^|\$$)/, '')
-      end
+      definition.properties["type"].pattern.source.gsub(/(^\^|\$$)/, "") if definition.properties["type"]
     end
   end
 end

data/lib/dato/json_schema_type.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Dato
+  class JsonSchemaType
+    attr_reader :schema
+
+    def initialize(schema)
+      @schema = schema
+    end
+
+    def call
+      type_property = find_info_for_type_property
+
+      return nil unless type_property
+
+      type_property.pattern.to_s.gsub(/(^(\(\?-mix:\^)|(\$\))$)/, "")
+    end
+
+    private
+
+    def find_info_for_type_property
+      entity = find_entity_in_data
+
+      return nil unless entity
+
+      entity.properties["type"]
+    end
+
+    def find_entity_in_data
+      return nil if !schema || !schema.properties["data"]
+
+      if schema.properties["data"].type.first == "array"
+        return schema.properties["data"].items if schema.properties["data"].items
+
+        return nil
+      end
+
+      return schema.properties["data"] if schema.properties["data"].type.first == "object"
+
+      if schema.properties["data"].any_of
+        return schema.properties["data"].any_of.reject { |x| x.definitions.type.example == "job" }
+      end
+
+      nil
+    end
+  end
+end

data/lib/dato/local/entities_repo.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dato/local/json_api_entity'
+require "dato/local/json_api_entity"
 
 module Dato
   module Local
@@ -27,8 +27,8 @@ module Dato
       end
 
       def destroy_item_type(id)
-        entities.fetch('item', {}).delete_if { |_item_id, item| item.item_type.id == id }
-        entities.fetch('item_type', {}).delete(id)
+        entities.fetch("item", {}).delete_if { |_item_id, item| item.item_type.id == id }
+        entities.fetch("item_type", {}).delete(id)
       end
 
       def upsert_entities(*payloads)

data/lib/dato/local/field_type/color.rb

@@ -4,14 +4,14 @@ module Dato
   module Local
     module FieldType
       class Color
-        attr_reader :red, :green, :blue, :alpha
+        attr_reader :red, :green, :blue
 
         def self.parse(value, _repo)
           value && new(
             value[:red],
             value[:green],
             value[:blue],
-            value[:alpha]
+            value[:alpha],
           )
         end
 
@@ -19,17 +19,21 @@ module Dato
           @red = red
           @green = green
           @blue = blue
-          @alpha = alpha / 255.0
+          @alpha = alpha
         end
 
         def rgb
-          if alpha == 1.0
+          if @alpha == 255
             "rgb(#{red}, #{green}, #{blue})"
           else
             "rgba(#{red}, #{green}, #{blue}, #{alpha})"
           end
         end
 
+        def alpha
+          @alpha / 255.0
+        end
+
         def hex
           r = red.to_s(16)
           g = green.to_s(16)
@@ -41,9 +45,9 @@ module Dato
           b = "0#{b}" if b.length == 1
           a = "0#{a}" if a.length == 1
 
-          hex = '#' + r + g + b
+          hex = "##{r}#{g}#{b}"
 
-          hex += a if a != 'ff'
+          hex += a if a != "ff"
 
           hex
         end
@@ -54,7 +58,7 @@ module Dato
             green: green,
             blue: blue,
             rgb: rgb,
-            hex: hex
+            hex: hex,
           }
         end
       end