dato 0.3.11 → 0.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eeb10e53337741f20ed958bfd8cbbe80577ac526
-  data.tar.gz: c070456c53cc99f91c8ed911e0fd9acaefcb33e4
+  metadata.gz: e24fe309b4524001a9cd2695edc7eac3ff9d8aa5
+  data.tar.gz: 71adfb4d2b30fd530625ec8ee57ac8057d545fde
 SHA512:
-  metadata.gz: bc9e32071f3ff430030762293cdd538629756604e74f856082ab267cefc0274fc21ca82c121d4b25f5074726de82e1156d1320c2ab005d4e3a54e681a05c9d36
-  data.tar.gz: 739ea4c921ee5b14cac770e083a6df9f65a04aab8acb9f6cfd98f367d33750fb22a8d47fcd993fc0a01df738cb9447b68156cef84a1040f4aaf07f388979c232
+  metadata.gz: 89d511f0d7508c6efa433faf17a149178041f5f4d08cc8bd3bd7bd19fa839e605cdcd6d1ec86fde3358cb3eb63456b89bd421d16283f3251e420dca98f4b26d5
+  data.tar.gz: 144cf0e4b41872b5b927b2a4152547881c966a8394d582c1b340e11cac779b5dea696a22deb7f7b02f872d47569df5fcb60088d56b4d2fbd39f9608839f37275

data/README.md

@@ -2,22 +2,19 @@
 
 [![Coverage Status](https://coveralls.io/repos/github/datocms/ruby-datocms-client/badge.svg?branch=master)](https://coveralls.io/github/datocms/ruby-datocms-client?branch=master) [![Build Status](https://travis-ci.org/datocms/ruby-datocms-client.svg?branch=master)](https://travis-ci.org/datocms/ruby-datocms-client) [![Gem Version](https://badge.fury.io/rb/dato.svg)](https://badge.fury.io/rb/dato)
 
-Ruby client for the DatoCMS API.
+CLI tool for DatoCMS (https://www.datocms.com).
 
-[DatoCMS](https://www.datocms.com/) is a fully customizable administrative area for your static websites:
+## How to integrate DatoCMS with Jekyll
 
-1. Use your favorite static website generator (Middleman, Hugo, Jekyll, and many others);
-2. Let your clients publish new content independently;
-3. Connect and build your site with any Continuous Deployment service (Netlify, Gitlab, CircleCI, etc.);
-4. Host the site anywhere you like (Amazon S3, Netlify, Surge.sh, etc.)
+Please head over the [Jekyll section of our documentation](https://docs.datocms.com/jekyll/overview.html) to learn everything you need to get started.
 
-## Usage
+## How to integrate DatoCMS with Middleman
 
-This gem can be used in different ways, so the documentation is split up in different files:
+For Middleman we have created a nice Middleman extension called [middleman-dato](https://github.com/datocms/middleman-dato). Please visit the [Middleman section of our documentation](https://docs.datocms.com/middleman/overview.html) to learn everything you need to get started.
 
-* [I want to use the content of a DatoCMS site in my static website (Hugo, Jekyll, etc.)](https://github.com/datocms/ruby-datocms-client/blob/master/docs/dato-cli.md);
-* [I want to edit the content of an existing DatoCMS site  programmatically](https://github.com/datocms/ruby-datocms-client/blob/master/docs/site-api-client.md);
-* [I want to create new DatoCMS sites programmatically](https://github.com/datocms/ruby-datocms-client/blob/master/docs/account-api-client.md).
+## API Client
+
+This gem also exposes an API client, useful ie. to import existing content in your DatoCMS administrative area. Read our [documentation](https://docs.datocms.com/api-client/ruby.html) for detailed info.
 
 ## Development
 

data/lib/dato/account/repo/site.rb

@@ -16,7 +16,7 @@ module Dato
         def create(resource_attributes)
           body = JsonApiSerializer.new(
             type: :site,
-            attributes: %i(domain internal_subdomain name notes template)
+            attributes: %i(domain internal_subdomain name notes ssg template)
           ).serialize(resource_attributes)
 
           post_request '/sites', body

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+#
+module Dato
+  module Local
+    module FieldType
+      class Color
+        attr_reader :red, :green, :blue, :alpha
+
+        def self.parse(value, _repo)
+          value && new(
+            value[:red],
+            value[:green],
+            value[:blue],
+            value[:alpha]
+          )
+        end
+
+        def initialize(red, green, blue, alpha)
+          @red = red
+          @green = green
+          @blue = blue
+          @alpha = alpha / 255.0
+        end
+
+        def rgb
+          if alpha == 1.0
+            "rgb(#{red}, #{green}, #{blue})"
+          else #
+            "rgba(#{red}, #{green}, #{blue}, #{alpha})"
+          end
+        end
+
+        def hex
+          r = red.to_s(16)
+          g = green.to_s(16)
+          b = blue.to_s(16)
+          a = (alpha * 255).to_i.to_s(16)
+
+          r = "0#{r}" if r.length == 1
+          g = "0#{g}" if g.length == 1
+          b = "0#{b}" if b.length == 1
+          a = "0#{a}" if a.length == 1
+
+          hex = '#' + r + g + b
+
+          hex += a if a != 'ff'
+
+          hex
+        end
+
+        def to_hash(*_args)
+          {
+            red: red,
+            green: green,
+            blue: blue,
+            rgb: rgb,
+            hex: hex
+          }
+        end
+      end
+    end
+  end
+end

data/lib/dato/site/repo/item.rb

@@ -24,7 +24,8 @@ module Dato
             :id,
             :updated_at,
             :is_valid,
-            :item_type
+            :item_type,
+            :last_editor
           )
 
           body = JsonApiSerializer.new(

data/lib/dato/site/repo/item_type.rb

@@ -8,8 +8,9 @@ module Dato
         def create(resource_attributes)
           body = JsonApiSerializer.new(
             type: :item_type,
-            attributes: %i(api_key name singleton sortable),
-            required_attributes: %i(api_key name singleton sortable)
+            attributes: %i(api_key name ordering_direction singleton sortable),
+            relationships: { ordering_field: { collection: false, type: :field } },
+            required_attributes: %i(api_key name ordering_direction singleton sortable)
           ).serialize(resource_attributes)
 
           post_request '/item-types', body
@@ -18,8 +19,9 @@ module Dato
         def update(item_type_id, resource_attributes)
           body = JsonApiSerializer.new(
             type: :item_type,
-            attributes: %i(api_key name singleton sortable),
-            required_attributes: %i(api_key name singleton sortable)
+            attributes: %i(api_key name ordering_direction singleton sortable),
+            relationships: { ordering_field: { collection: false, type: :field } },
+            required_attributes: %i(api_key name ordering_direction singleton sortable)
           ).serialize(resource_attributes, item_type_id)
 
           put_request "/item-types/#{item_type_id}", body

data/lib/dato/site/repo/site.rb

@@ -12,7 +12,7 @@ module Dato
         def update(resource_attributes)
           body = JsonApiSerializer.new(
             type: :site,
-            attributes: %i(deploy_adapter deploy_settings favicon global_seo locales name no_index ssg theme_hue timezone)
+            attributes: %i(deploy_adapter deploy_settings favicon frontend_url global_seo locales name no_index ssg theme_hue timezone)
           ).serialize(resource_attributes)
 
           put_request '/site', body

data/lib/dato/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Dato
-  VERSION = '0.3.11'
+  VERSION = '0.3.12'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dato
 version: !ruby/object:Gem::Version
-  version: 0.3.11
+  version: 0.3.12
 platform: ruby
 authors:
 - Stefano Verna
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-23 00:00:00.000000000 Z
+date: 2017-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -367,9 +367,6 @@ files:
 - bin/console
 - bin/setup
 - dato.gemspec
-- docs/account-api-client.md
-- docs/dato-cli.md
-- docs/site-api-client.md
 - exe/dato
 - lib/dato.rb
 - lib/dato/account/client.rb
@@ -398,6 +395,7 @@ files:
 - lib/dato/json_api_serializer.rb
 - lib/dato/local/entities_repo.rb
 - lib/dato/local/field_type/boolean.rb
+- lib/dato/local/field_type/color.rb
 - lib/dato/local/field_type/date.rb
 - lib/dato/local/field_type/date_time.rb
 - lib/dato/local/field_type/file.rb
@@ -474,4 +472,3 @@ signing_key:
 specification_version: 4
 summary: Ruby client for DatoCMS API
 test_files: []
-has_rdoc: 

data/docs/account-api-client.md

@@ -1,53 +0,0 @@
-# Create/edit sites within a DatoCMS account 
-
-With this gem, you can easily create, edit and destroy DatoCMS sites, as well as editing your account settings.
-
-# Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'dato'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install dato
-
-## Usage
-
-```ruby
-require "dato"
-
-# fetch existing sites
-sites = client.sites.all
-
-# create a new site
-site = client.sites.create(name: 'Foobar')
-
-# update an existing site
-client.sites.update(site[:id], site.merge(name: 'Blog'))
-
-# destroy an existing site
-client.sites.destroy(new_site[:id])
-```
-
-## List of client methods
-
-```ruby
-client.account.find
-client.account.create(resource_attributes)
-client.account.update(resource_attributes)
-client.account.reset_password(resource_attributes)
-
-client.sites.find(site_id)
-client.sites.all
-client.sites.create(resource_attributes)
-client.sites.update(site_id, resource_attributes)
-client.sites.destroy(site_id)
-client.sites.duplicate(site_id, resource_attributes)
-```

data/docs/dato-cli.md

@@ -1,258 +0,0 @@
-# Integrating DatoCMS with your static website generator
-
-[DatoCMS](https://www.datocms.com) is working hard to provide the easiest way to enable non-technical editors to update a completely static website — without the intervention of a developer — from the comfort of a user-friendly web interface, just like they're used with Wordpress and such.
-
-Middleman, Hugo, Jekyll, Hexo, Pelican, Octopress, GatsbyJS... the list of static site generators is [almost endless](https://www.staticgen.com/) and keeps on growing.
-
-This gem provides an easy way to integrate content coming from a DatoCMS into virtually any static website generator.
-
-# How it works
-
-All the websites built with a static website generator are made of:
-
-* Static files which represent the actual content of the pages (usually written in Markdown + [front matter](https://jekyllrb.com/docs/frontmatter/), YAML, JSON or Toml);
-* Some HTML templates that use these files to generate the actual static HTML pages you will upload online.
-
-That means that, up until now, even the most basic change to a static website could only be performed by a tech-savvy user, as too many things had to be known (Git, Markdown syntax, proper editing of YAML/JSON/Toml files).
-
-DatoCMS works differently:
-
-1. You create a web administrative interface for your editors that fits exactly the needs of your static website;
-2. Editors can make changes to the content of the website from that CMS interface you prepared;
-3. Using this gem, all the data stored in your DatoCMS administrative interface can be transformed into local Markdown/YAML/JSON/Toml files, so that can be "digested" by the static website generator just as they were written by hand.
-
-The process of translating the data coming from the API into static files can be performed both on your machine during the development process of the website, and in your Continuous Deployment service anytime the editors request a new "build" pressing a "Publish" button on the web interface.
-
-Now your static website isn't static anymore! Isn't this awesome?! :-) 
-
-## Installing the CLI tool
-
-Once you have a working Ruby environment, you can use the CLI tool running these commands within your static website directory:
-
-```
-gem install bundler
-bundle init
-echo 'gem "dato"' >> Gemfile
-bundle install
-```
-
-If everything worked correctly, you should now run `bundle exec dato` and see something like this:
-
-```
-$ bundle exec dato
-DatoCMS commands:
-  dato dump --token=TOKEN  # dumps DatoCMS content into local files
-  dato help [COMMAND]      # Describe available commands or one specific command
-```
-
-Great! Now the easiest way to dump all the remote data into local files is to create a `dato.config.rb` file into your project root directory with the following content:
-
-```ruby
-# dato.config.rb
-dato.available_locales.each do |locale|
-  directory "content/#{locale}" do
-    I18n.with_locale(locale) do
-      create_data_file "site.yml", :yaml, dato.site.to_hash
-      dato.item_types.each do |item_type|
-        create_data_file "#{item_type.api_key}.yml", :yaml, 
-          dato.items_of_type(item_type).map(&:to_hash)
-      end
-    end
-  end
-end
-```
-
-And run the following command:
-
-```
-$ bundle exec dato dump --token=SITE_READONLY_TOKEN 
-```
-
-Hurray! A new `content` directory should have been generated with a Yaml file for each item type and the site itself!
-
-## Hugo step-by-step integration guide
-
-That's just the beginning: it probably makes more sense if you generate local files following the precise guidelines of the static site generator you're using. You can easily configure the `dato.config.rb` file to achieve that.
-
-Just to make things more down-to-heart, suppose we're working with a Hugo website with the following structure:
-
-```
-.
-├── config.toml
-├── content
-|   ├── post
-|   |   ├── first-post.md
-|   |   └── ...
-|   └── quote
-|   |   ├── first-quote.md
-|   |   └── ...
-├── data
-|   └── author
-|       ├── mark.toml
-|       └── ...
-├── layouts
-|   └── ...
-└── static
-    └── ...
-```
-
-Our job is to generate the Markdown files in the `content` directory from the data contained in our DatoCMS site. The Toml files contained in the in the `data` directory need to be generated as well.
-
-### Set up the site
-
-Using the DatoCMS web interface, we first create the following Item types:
-
-* post
-  - title (string, required)
-  - slug (slug, required)
-  - publication_date (date, required)
-  - body (text, required)
-
-* author
-  - name (string, required, title)
-  - slug (slug, required)
-  - bio (text, required)
-
-* quote
-  - content (text, required)
-  - author (link to author, required)
-
-### Writing the config file
-
-We then define how content stored in DatoCMS needs to be translated into local files inside the `dato.config.rb` config file. Let's start with posts:
-
-```ruby
-directory "content/post" do
-  dato.posts.each do |item|
-    create_post "#{item.slug}.md" do
-      frontmatter :toml, {
-        title: item.title,
-        date: item.publication_date.to_s
-      }
-
-      content item.body
-    end
-  end
-end
-```
-
-The DSL is quite terse! Basically we're declaring that:
-
-1. we want to take possess of the directory `content/post` and manage it programmatically from now on;
-2. we then iterate over each post stored in DatoCMS and...
-3. for each post, we create a local markdown file:
-  - named after the slugified version of the post title;
-  - that contains the post body;
-  - decorated with a Toml front matter with a `title` and `date` keys; 
-
-Now we can run the following command:
-
-```
-$ bundle exec dato dump --token=SITE_READONLY_TOKEN 
-```
-
-And see the `content/post` directory emptied from previous content and filled with new files:
-
-```
-.
-└── content
-    └── post
-        ├── lorem-ipsum.md
-        ├── dolor-sit-amet.md
-        ├── consectetur-adipisci.md
-        └── ...
-```
-
-Let's open one of those Markdown files:
-
-```
-+++
-title = "Lorem ipsum"
-date = "2001-02-03"
-+++
-
-Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
-
-Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. 
-```
-
-Awesome!! We can now continue using Hugo just like we're used to.
-
-### A more complete config file
-
-The config file let us declare different kind of "operations":
-
-| Command | Description |
-| --- | --- |
-| `create_post` | Generate Markdown + Frontmatter files |
-| `create_data_file` | Generate plain Toml/YAML files |
-| `add_to_data_file` | Add some keys to an existing Toml/YAML file |
-
-In fact, this is a more complete version of our `dato.config.rb` file:
-
-```ruby
-directory "content/post" do
-  dato.posts.each do |item|
-    create_post "#{item.slug}.md" do
-      frontmatter :toml, {
-        title: item.title,
-        date: item.publication_date.to_s
-      }
-
-      content item.body
-    end
-  end
-end
-
-directory "content/quote" do
-  dato.quotes.each_with_index do |item, i|
-    create_post "#{item.id}.md" do
-      frontmatter :toml, {
-        title: "Quote number #{i}",
-        weight: i
-      }
-
-      content item.content
-    end
-  end
-end
-
-directory "data/authors" do
-  dato.authors.each do |item|
-    create_data_file "#{item.slug}.toml", :toml, {
-      name: item.name,
-      bio: item.bio
-    }
-  end
-end
-```
-
-### How to fetch data from DatoCMS
-
-Using the `dato` method you can access to any item stored in your site grouped by item type. That is, if your site has an Item Type with `post` as API identifier, you can get the complete array of items with `dato.posts` (the pluralized API identifier).
-
-If a Item Type is marked as "single instance" (ie. `about_page`) you don't need to pluralize and a call to `dato.about_page` directly returns the item (or `nil`, if still hasn't been created within the CMS).
-
-You can query an item's field value with a method called like the field API identifier.
-
-Complex field types (ie. `image`, `file`, `video`, `seo`) implement specific methods you can use as well within the config file:
-
-```
-article = dato.articles.first
-
-article.cover_image.url(w: 500, fit: 'crop')
-article.video.iframe_embed(800, 600)
-```
-
-### Examples
-
-To help you with your first integration, here's a list of sample websites integrated with DatoCMS we built:
-
-* [Middleman](https://github.com/datocms/middleman-example)
-* [Jekyll](https://github.com/datocms/jekyll-example)
-* [Hugo](https://github.com/datocms/hugo-example)
-
-### Need more help?
-
-Just ask! Send us an email to [support@datocms.com](mailto:support@datocms.com) and we'll be happy to answer any question!
-

data/docs/site-api-client.md

@@ -1,121 +0,0 @@
-# Edit the content of an existing DatoCMS site
-
-With this gem, you can easily create, edit and destroy any object within a DatoCMS site:
-
-* Item types
-* Fields
-* Items
-* Menu items
-* Users
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'dato'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install dato
-
-## Usage
-
-```ruby
-require "dato"
-
-# create a DatoCMS client
-client = Dato::Site::Client.new("YOUR_SITE_API_READWRITE_TOKEN")
-
-# create a new Article item type
-article_type = client.item_types.create(
-  name: "Article",
-  singleton: false,
-  sortable: false,
-  api_key: "article"
-)
-
-# add a Title field to the Article item type
-client.fields.create(
-  article_type[:id],
-  api_key: "title",
-  field_type: "string",
-  appeareance: { type: "title" },
-  label: "Title",
-  localized: false,
-  position: 99,
-  hint: "",
-  validators: { required: {} },
-)
-
-# add an Image field to the Article item type
-client.fields.create(
-  article_type[:id],
-  api_key: "image",
-  field_type: "image",
-  appeareance: nil,
-  label: "Image",
-  localized: false,
-  position: 99,
-  hint: "",
-  validators: { required: {} },
-)
-
-# create a new Article
-client.items.create(
-  item_type: article_type[:id],
-  title: "My first article!",
-  image: client.upload_image("http://i.giphy.com/NXOF5rlaSXdAc.gif")
-)
-
-# fetch and edit an existing Article
-article = client.items.find("1234")
-client.items.update("1234", article.merge(title: "New title"))
-
-# destroy an existing article
-client.items.destroy("1234")
-```
-
-## List of client methods
-
-```ruby
-client.fields.create(item_type_id, resource_attributes)
-client.fields.update(field_id, resource_attributes)
-client.fields.all(item_type_id)
-client.fields.find(field_id)
-client.fields.destroy(field_id)
-
-client.items.create(resource_attributes)
-client.items.update(item_id, resource_attributes)
-client.items.all(filters = {})
-client.items.find(item_id)
-client.items.destroy(item_id)
-
-client.item_types.create(resource_attributes)
-client.item_types.update(item_type_id, resource_attributes)
-client.item_types.all
-client.item_types.find(item_type_id)
-client.item_types.destroy(item_type_id)
-
-client.menu_items.create(resource_attributes)
-client.menu_items.update(menu_item_id, resource_attributes)
-client.menu_items.all
-client.menu_items.find(menu_item_id)
-client.menu_items.destroy(menu_item_id)
-
-client.site.find
-client.site.update(resource_attributes)
-
-client.upload_image(path_or_url)
-client.upload_file(path_or_url)
-
-client.users.create(resource_attributes)
-client.users.all
-client.users.find(user_id)
-client.users.destroy(user_id)
-```