netlify 0.1.0

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/*_test.rb"
+end

data/lib/netlify.rb

@@ -0,0 +1,17 @@
+require "json"
+require "netlify/version"
+require "netlify/client"
+require "netlify/collection_proxy"
+require "netlify/model"
+require "netlify/sites"
+require "netlify/forms"
+require "netlify/submissions"
+require "netlify/files"
+require "netlify/snippets"
+require "netlify/users"
+require "netlify/deploys"
+require "netlify/dns_zones"
+require "netlify/access_tokens"
+require "netlify/multipass"
+
+module Netlify; end

data/lib/netlify/access_token.rb

@@ -0,0 +1,5 @@
+module Netlify
+  class AccessToken < Model
+    fields :id, :access_token, :user_id, :created_at
+  end
+end

data/lib/netlify/access_tokens.rb

@@ -0,0 +1,7 @@
+require "Netlify/access_token"
+
+module Netlify
+  class AccessTokens < CollectionProxy
+    path "/access_tokens"
+  end
+end

data/lib/netlify/client.rb

@@ -0,0 +1,113 @@
+require 'oauth2'
+
+module Netlify
+  class Client
+    ENDPOINT    = ENV['OAUTH_CLIENT_API_URL'] || 'https://api.netlify.com'
+    API_VERSION = "v1"
+    RETRIES     = 3
+
+    class NetlifyError < StandardError; end
+    class NotFoundError < NetlifyError; end
+    class ConnectionError < NetlifyError; end
+    class InternalServerError < NetlifyError; end
+    class AuthenticationError < NetlifyError; end
+
+    attr_accessor :client_id, :client_secret, :oauth, :access_token, :endpoint
+
+    def initialize(options)
+      self.client_id     = options[:client_id]
+      self.client_secret = options[:client_secret]
+      self.access_token  = options[:access_token]
+      self.endpoint      = options[:endpoint] || ENDPOINT
+      self.oauth         = OAuth2::Client.new(client_id, client_secret, :site => endpoint, :connection_build => lambda {|f|
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter :net_http
+      })
+    end
+
+    def authorize_url(options)
+      oauth.auth_code.authorize_url(options)
+    end
+
+    def authorize_from_code!(authorization_code, options)
+      @oauth_token = oauth.auth_code.get_token(authorization_code, options)
+      self.access_token = oauth_token.token
+    end
+
+    def authorize_from_credentials!
+      @oauth_token = oauth.client_credentials.get_token
+      self.access_token = oauth_token.token
+    end
+
+    def sites
+      Sites.new(self)
+    end
+
+    def forms
+      Forms.new(self)
+    end
+
+    def submissions
+      Submissions.new(self)
+    end
+
+    def users
+      Users.new(self)
+    end
+
+    def dns_zones
+      DnsZones.new(self)
+    end
+
+    def access_tokens
+      AccessTokens.new(self)
+    end
+
+    def request(verb, path, opts={}, &block)
+      retries = 0
+      begin
+        raise AuthenticationError, "Authorize with Netlify before making requests" unless oauth_token
+
+        oauth_token.request(verb, ::File.join("/api", API_VERSION, path), opts, &block)
+      rescue OAuth2::Error => e
+        case e.response.status
+        when 401
+          raise AuthenticationError, message_for(e, "Authentication Error")
+        when 404
+          raise NotFoundError, message_for(e, "Not Found")
+        when 500
+          if retry_request?(verb, e.response.status, retries)
+            retries += 1
+            retry
+          else
+            raise InternalServerError, message_for(e, "Internal Server Error")
+          end
+        else
+          raise NetlifyError, message_for(e, "OAuth2 Error")
+        end
+      rescue Faraday::Error::ConnectionFailed, Faraday::Error::TimeoutError => e
+        if retry_request?(verb, e.response && e.response.status, retries)
+          retries += 1
+          retry
+        else
+          raise ConnectionError, message_for(e, "Connection Error")
+        end
+      end
+    end
+
+    private
+    def retry_request?(http_verb, status_code, retries)
+      return false unless [:get, :put, :delete, :head].include?(http_verb.to_s.downcase.to_sym)
+      return retries < 3 unless status_code && status_code == 422
+    end
+
+    def oauth_token
+      @oauth_token ||= access_token && OAuth2::AccessToken.new(oauth, access_token)
+    end
+
+    def message_for(error, default)
+      error.message.strip == "" ? default : error.message
+    end
+  end
+end

data/lib/netlify/collection_proxy.rb

@@ -0,0 +1,48 @@
+module Netlify
+  class CollectionProxy
+    include Enumerable
+
+    attr_accessor :client, :prefix
+
+    def self.path(value = nil)
+      return @path unless value
+      @path = value
+    end
+
+    def self.model(value = nil)
+      @model ||= Netlify.const_get(to_s.split("::").last.sub(/s$/, ''))
+    end
+
+    def initialize(client, prefix = nil)
+      self.client = client
+      self.prefix = prefix
+    end
+
+    def all(options = {})
+      response = client.request(:get, path, {:params => options})
+      response.parsed.map {|attributes| model.new(client, attributes.merge(:prefix => prefix)) } if response.parsed
+    end
+
+    def each(&block)
+      all.each(&block)
+    end
+
+    def get(id)
+      response = client.request(:get, ::File.join(path, id))
+      model.new(client, response.parsed.merge(:prefix => prefix)) if response.parsed
+    end
+
+    def create(attributes)
+      response = client.request(:post, path, :body => attributes)
+      model.new(client, response.parsed.merge(:prefix => prefix)) if response.parsed
+    end
+
+    def model
+      self.class.model
+    end
+
+    def path
+      [prefix, self.class.path].compact.join("/")
+    end
+  end
+end

data/lib/netlify/deploy.rb

@@ -0,0 +1,58 @@
+module Netlify
+  class Deploy < Model
+    fields :id, :state, :premium, :claimed, :name, :custom_domain, :url,
+           :admin_url, :deploy_url, :screenshot_url, :created_at, :updated_at,
+           :user_id, :required
+
+    def upload_dir(dir)
+      return unless state == "uploading"
+
+      shas = Hash.new { [] }
+      glob = ::File.join(dir, "**", "*")
+
+      Dir.glob(glob) do |file|
+        next unless ::File.file?(file)
+        pathname = ::File.join("/", file[dir.length..-1])
+        next if pathname.match(/(^\/?__MACOSX\/|\/\.)/)
+        sha = Digest::SHA1.hexdigest(::File.read(file))
+        shas[sha] = shas[sha] + [pathname]
+      end
+
+      (required || []).each do |sha|
+        shas[sha].each do |pathname|
+          client.request(:put, ::File.join(path, "files", URI.encode(pathname)), :body => ::File.read(::File.join(dir, pathname)), :headers => {"Content-Type" => "application/octet-stream"})
+        end
+      end
+
+      refresh
+    end
+
+    def wait_for_ready(timeout = 900)
+      start = Time.now
+      while !(ready?)
+        sleep 5
+        refresh
+        puts "Got state: #{state}"
+        raise "Error processing site: #{error_message}" if error?
+        yield(self) if block_given?
+        raise "Timeout while waiting for ready" if Time.now - start > timeout
+      end
+      self
+    end
+
+    def ready?
+      state == "ready"
+    end
+
+    def error?
+      state == "error"
+    end
+
+    def publish
+      response = client.request(:post, ::File.join(path, "restore"))
+      process(response.parsed)
+      self
+    end
+    alias :restore :publish
+  end
+end

data/lib/netlify/deploys.rb

@@ -0,0 +1,43 @@
+require "Netlify/deploy"
+
+module Netlify
+  class Deploys < CollectionProxy
+    path "/deploys"
+
+    def create(attributes)
+      if attributes[:dir]
+        response = client.request(:post, path,
+          :body => JSON.generate({:files => inventory(attributes[:dir]), :draft => attributes[:draft] || false}),
+          :headers => {"Content-Type" => "application/json"}
+        )
+        Deploy.new(client, response.parsed).tap do |deploy|
+          deploy.upload_dir(attributes[:dir])
+        end
+      elsif attributes[:zip]
+        request_path = attributes[:draft] ? "#{path}?draft=true" : path
+        response = client.request(:post, request_path,
+          :body => ::File.read(attributes[:zip]),
+          :headers => {"Content-Type" => "application/zip"}
+        )
+        Deploy.new(client, response.parsed)
+      else
+        raise "Need dir or zip to create a deploy"
+      end
+    end
+
+    def draft(attributes)
+      create(attributes.merge(:draft => true))
+    end
+
+    private
+    def inventory(dir)
+      files = {}
+      Dir[::File.join(dir, "**", "*")].each do |file|
+        next unless ::File.file?(file)
+        path = ::File.join("/", file[dir.length..-1])
+        files[path] = Digest::SHA1.hexdigest(::File.read(file))
+      end
+      files
+    end
+  end
+end

data/lib/netlify/dns_record.rb

@@ -0,0 +1,5 @@
+module Netlify
+  class DnsRecord < Model
+    fields :id, :hostname, :type, :value, :ttl, :domain_id
+  end
+end

data/lib/netlify/dns_records.rb

@@ -0,0 +1,7 @@
+require "Netlify/dns_record"
+
+module Netlify
+  class DnsRecords < CollectionProxy
+    path "/dns_records"
+  end
+end

data/lib/netlify/dns_zone.rb

@@ -0,0 +1,11 @@
+require "Netlify/dns_records"
+
+module Netlify
+  class DnsZone < Model
+    fields :id, :name, :user_id, :created_at, :updated_at
+
+    def dns_records
+      DnsRecords.new(client, path)
+    end
+  end
+end

data/lib/netlify/dns_zones.rb

@@ -0,0 +1,11 @@
+require "Netlify/dns_zone"
+
+module Netlify
+  class DnsZones < CollectionProxy
+    path "/dns_zones"
+
+    def dns_records
+      DnsRecords.new(client, path)
+    end
+  end
+end

data/lib/netlify/file.rb

@@ -0,0 +1,5 @@
+module Netlify
+  class File < Model
+    fields :id, :path, :sha, :mime_type, :size
+  end
+end

data/lib/netlify/files.rb

@@ -0,0 +1,7 @@
+require "Netlify/file"
+
+module Netlify
+  class Files < CollectionProxy
+    path "/files"
+  end
+end

data/lib/netlify/form.rb

@@ -0,0 +1,9 @@
+module Netlify
+  class Form < Model
+    fields :id, :site_id, :name, :paths, :submission_count, :fields, :created_at
+
+    def submissions
+      Submissions.new(client, path)
+    end
+  end
+end

data/lib/netlify/forms.rb

@@ -0,0 +1,7 @@
+require "Netlify/form"
+
+module Netlify
+  class Forms < CollectionProxy
+    path "/forms"
+  end
+end

data/lib/netlify/model.rb

@@ -0,0 +1,65 @@
+module Netlify
+  class Model
+    attr_reader :client, :attributes, :prefix
+
+    def self.fields(*names)
+      return @fields if names.empty?
+
+      @fields ||= []
+
+      names.each do |name|
+        define_method name do
+          @attributes[name.to_sym]
+        end
+
+        define_method "#{name}=" do |value|
+          @attributes[name.to_sym] = value
+        end
+
+        @fields.push(name.to_sym)
+      end
+    end
+
+    def self.collection(value = nil)
+      @collection ||= Netlify.const_get(to_s.split("::").last + "s")
+    end
+
+    def initialize(client, attributes)
+      @client = client
+      @attributes = {}
+      @prefix = attributes.delete(:prefix)
+      process(attributes)
+    end
+
+    def process(attributes)
+      self.class.fields.each do |field|
+        if attributes.has_key?(field) || attributes.has_key?(field.to_s)
+          @attributes[field] = attributes[field] || attributes[field.to_s]
+        end
+      end
+      self
+    end
+
+    def update(attributes)
+      response = client.request(:put, path, :body => attributes)
+      process(response.parsed) if response.parsed
+    end
+
+    def destroy
+      client.request(:delete, path)
+    end
+
+    def refresh
+      response = client.request(:get, path)
+      process(response.parsed)
+    end
+
+    def collection
+      self.class.collection
+    end
+
+    def path
+      ::File.join(*[prefix, collection.path, id.to_s].compact)
+    end
+  end
+end