netlify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 500cb94ed39ac0ca44ca44deb7a447dfd566b15a
+  data.tar.gz: 48194a2bc54a43d712c9cceb2b26b3835ed590a3
+SHA512:
+  metadata.gz: 8614bd0635a023f9f63bcb7663c7f6930b3d8867b948324ec3784c986f90799740ebbbd849d1285aaa73fc61fbf3a294e36be3199649c8ecd691e85a569db1e3
+  data.tar.gz: 42f05bd119c82170e2c6e121cedeb6b28c85527ef0d88ea5e11bc1b8e2296f03fde5c09cd393ab30e797595dc16172b6a80853ccfc9bfb717f2ab78106de047a

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in Netlify.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    netlify (0.2.1)
+      highline
+      oauth2 (>= 0.9.2)
+      slop
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.3)
+    crack (0.3.2)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    highline (1.6.21)
+    jwt (1.0.0)
+    minitest (5.0.8)
+    multi_json (1.10.1)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    oauth2 (1.0.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    slop (3.6.0)
+    webmock (1.11.0)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest
+  netlify!
+  webmock

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mathias Biilmann Christensen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,423 @@
+Netlify Ruby Client
+======================
+
+Netlify is a hosting service for the programmable web. It understands your documents, processes forms and lets you do deploys, manage forms submissions, inject javascript snippets into sites and do intelligent updates of HTML documents through it's API.
+
+The basic flow to using the ruby client is:
+
+1. Authenticate (via credentials or a previously aquired access token)
+2. Get site (via id)
+3. Deploy
+  * If site has not been deployed to yet, then the above step will throw a `not found` exception, and you'll need to use `Netlify.sites.create` to create the site and do the initial deploy.
+  * If the site has already been deployed and the above step was successful, you can simply use `site.update` to re-deploy.
+
+If you'd rather, there's also a command line utility to handle most of these steps: `Netlify deploy`.
+
+Installation
+============
+
+Install the gem by running
+
+    gem install netlify
+
+or put it in a Gemfile and run `bundle install`
+
+    gem netlify
+
+
+Authenticating
+==============
+
+Register a new application at https://app.netlify.com/applications to get your Oauth2 secret and key.
+
+Once you have your credentials you can instantiate a Netlify client.
+
+```ruby
+Netlify = Netlify::Client.new(:client_id => "YOUR_API_KEY", :client_secret => "YOUR_API_SECRET")
+```
+
+Before you can make any requests to the API, you'll need to authenticate with OAuth2. The Netlify client supports two OAuth2 flows.
+
+If you're authenticating on behalf of a user, you'll need to get a valid access token for that user. Use the Netlify client to request an authentication URL:
+
+```ruby
+url = Netlify.authorize_url(:redirect_uri => "http://www.example.com/callback")
+```
+
+The user then visits that URL and will be prompted to authorize your application to access his Netlify sites. If she grants permission, she'll be redirected back to the `redirect_uri` provided in the `authorize_url` call. This URL must match the redirect url configured for your Netlify application. Once the user comes back to your app, you'll be able to access a `code` query parameter that gives you an authorization code. Use this to finish the OAuth2 flow:
+
+```ruby
+Netlify.authorize!(token, :redirect_uri => "http://www.example.com/callback")
+```
+
+If you're not authenticating on behalf of a user you can authorize directly with the API credentials. Just call:
+
+```ruby
+Netlify.authorize_from_credentials!
+```
+
+If you already have an OAuth2 `access_token` you can instantiate the client like this:
+
+```ruby
+Netlify = Netlify::Client.new(:access_token => access_token)
+```
+
+And the client will be ready to do requests without having to use `authorize_from_credentials`. This means that once you've gotten a token via `authorize_from_credentials!` you can store it and reuse it for later sessions.
+
+If you're authenticating via the `access_token` and you'd like to test if you have a valid `access_token`, you can attempt to make a request with the Netlify client and if the token is invalid, a `Netlify::Client::AuthenticationError` will be raised. See Miles Matthias' [Netlify Rakefile](https://github.com/milesmatthias/Netlify-rakefile) for an example.
+
+
+Sites
+=====
+
+Getting a list of all sites you have access to:
+
+```ruby
+Netlify.sites.each do |site|
+  puts site.id
+  puts site.url
+end
+```
+
+Each site has a unique, system generated id. Getting a specific site by id:
+
+```ruby
+site = Netlify.sites.get(id)
+```
+
+Creating a site from a directory: _(note the path given is a system path)_
+
+```ruby
+site = Netlify.sites.create(:dir => "my-site")
+puts site.id
+```
+
+You'll want to then save that site id for future reference. Note that a site can also be looked up by its `url`.
+
+Creating a site from a zip file:
+
+```ruby
+site = Netlify.sites.create(:zip => "/tmp/my-site.zip")
+```
+
+Both methods will create the site and upload the files to a new deploy.
+
+Creating a site with a dir or a zip is actually a shortcut for this:
+
+```ruby
+site = Netlify.sites.create(:name => "unique-site-subdomain", :custom_domain => "www.example.com")
+deploy = site.deploys.create(:dir => "path/to/my-site")
+```
+
+Use `wait_for_ready` to wait until a site has finished processing.
+
+```ruby
+site = Netlify.sites.create(:dir => "/tmp/my-site")
+site.wait_for_ready
+site.state == "ready"
+```
+
+This also works on a specific deploy, and you can pass in a block to execute after each polling action:
+
+```ruby
+deploy = site.deploys.create(:dir => "/tmp/my-site")
+deploy.wait_for_ready do |deploy|
+  puts "Current state: #{deploy.state}"
+end
+```
+
+Redeploy a site from a dir:
+
+```ruby
+site = Netlify.sites.get(site_id)
+deploy = site.deploys.create(:dir => "/tmp/my-site")
+deploy.wait_for_ready
+```
+
+Redeploy a site from a zip file:
+
+```ruby
+site = Netlify.sites.get(site_id)
+deploy = site.deploys.create(:zip => "/tmp/my-site.zip")
+deploy.wait_for_ready
+```
+
+Update the name of the site (its subdomain), the custom domain and the notification email for form submissions:
+
+```ruby
+    site.update(:name => "my-site", :custom_domain => "www.example.com", :notification_email => "me@example.com", :password => "secret-password")
+```
+
+Deleting a site:
+
+```ruby
+    site.destroy!
+```
+
+Deploys
+=======
+
+Access all deploys for a site
+
+```ruby
+site = Netlify.sites.get(site_id)
+site.deploys.all
+```
+
+Access a specific deploy
+
+```ruby
+site = Netlify.sites.get(site_id)
+deploy = site.deploys.get(id)
+```
+
+Publish a deploy (makes it the current live version of the site)
+
+```ruby
+site.deploys.get(id).publish
+```
+
+Create a new deploy
+
+```ruby
+deploy = site.deploys.create(:dir => "/tmp/my-site")
+```
+
+Create a draft deploy
+
+```ruby
+deploy = site.deploys.draft(:dir => "/tmp/my-site")
+```
+
+Or
+
+```ruby
+deploy = site.deploys.create(:dir => "/tmp/my-site", :draft => true)
+```
+
+This will upload and process a deploy. You can view the deploy at `deploy.deploy_url` and make it the live version of the site with `deploy.publish`.
+
+
+Users
+=====
+
+Access all users you have access to
+
+```ruby
+Netlify.users.all
+```
+
+Access a specific user
+
+```ruby
+Netlify.users.get(id)
+```
+
+Create a user. **Reseller only**. A unique email is required. You can optionally include a unique uid, typically the database ID you use for the user on your end.
+
+```ruby
+Netlify.users.create(:email => "some@email.com", :uid => "12345")
+```
+
+Update a user. **Reseller only**.
+
+```ruby
+Netlify.users.get(id).update(:email => "new@email.com", :uid => "12345")
+```
+
+Delete a user. **Reseller only**
+
+```ruby
+Netlify.users.get(id).destroy
+```
+
+Get all sites for a user
+
+```ruby
+Netlify.users.get(id).sites
+```
+
+Get all form submissions for a user
+
+```ruby
+Netlify.users.get(id).submissions
+```
+
+Forms
+=====
+
+Access all forms you have access to:
+
+```ruby
+    Netlify.forms.all
+```
+
+Access forms for a specific site:
+
+```ruby
+    site = Netlify.sites.get(id)
+    site.forms.all
+```
+
+Access a specific form:
+
+```ruby
+    form = Netlify.forms.get(id)
+```
+
+Access a list of all form submissions you have access to:
+
+```ruby
+    Netlify.submissions.all
+```
+
+Access submissions from a specific site
+
+```ruby
+    site = Netlify.sites.get(id)
+    site.submissions.all
+```
+
+Access submissions from a specific form
+
+```ruby
+    form = Netlify.forms.get(id)
+    form.submissions.all
+```
+
+Get a specific submission
+
+```ruby
+    Netlify.submissions.get(id)
+```
+
+Files
+=====
+
+Access all files in a site:
+
+```ruby
+    site = Netlify.sites.get(id)
+    site.files.all
+```
+
+Get a specific file:
+
+```ruby
+    file = site.files.get(path) # Example paths: "/css/main.css", "/index.html"
+```
+
+Reading a file:
+
+```ruby
+    file.read
+```
+
+Snippets
+========
+
+Snippets are small code snippets injected into all HTML pages of a site right before the closing head or body tag. To get all snippets for a site:
+
+```ruby
+site = Netlify.sites.get(id)
+site.snippets.all
+```
+
+Get a specific snippet
+
+```ruby
+site.snippets.get(0)
+```
+
+Add a snippet to a site.
+
+You can specify a `general` snippet that will be inserted into all pages, and a `goal` snippet that will be injected into a page following a successful form submission. Each snippet must have a title. You can optionally set the position of both the general and the goal snippet to `head` or `footer` to determine if it gets injected into the head tag or at the end of the page.
+
+```ruby
+site.snippets.create(
+  :general => general_snippet,
+  :general_position => "footer",
+  :goal => goal_snippet,
+  :goal_position => "head",
+  :title => "My Snippet"
+)
+```
+
+Update a snippet
+
+```ruby
+site.snippets.get(id).update(
+  :general => general_snippet,
+  :general_position => "footer",
+  :goal => goal_snippet,
+  :goal_position => "head",
+  :title => "My Snippet"
+)
+```
+
+Remove a snippet
+
+```ruby
+site.snippet.get(id).destroy
+end
+```
+
+DNS Zones
+=========
+
+Resellers can manage DNS Zones through the ruby client. To use this feature your access token must belong to a reseller administrator.
+
+Create a DNS Zone
+
+```ruby
+Netlify.dns_zones.create(:name => "www.example.com", :user_id => "1234")
+```
+
+Get all DNS Zones
+
+```ruby
+Netlify.dns_zones.all
+```
+
+Delete a DNS Zone
+
+```ruby
+dns_zone.destroy
+```
+
+Get all dns records for a zone
+
+```ruby
+dns_zone.dns_records.all
+```
+
+Adding a new record (supported types: A, CNAME, TXT, MX)
+
+```ruby
+dns_zone.dns_records.create(:hostname => "www", :type => "CNAME", :value => "Netlify.com", :ttl => "500")
+```
+
+Deleting a record
+
+```ruby
+dns_record.destroy
+```
+
+Access Tokens
+=============
+
+Resellers can create and revoke access tokens on behalf of their users. To use this feature your access token must belong to a reseller administrator.
+
+Create access token:
+
+```ruby
+Netlify.access_tokens.create(:user => {:email => "test@example.com", :uid => 123})
+```
+
+The user must have either an email or a uid or both. Both email and uid must be unique within your reseller account. The uid would typically correspond to your internal database id for the user. If the users doesn't exist, a new user will be created on the fly.
+
+Revoke access token:
+
+```ruby
+Netlify.access_tokens.get("token-string").destroy
+```