fjords-client 0.0.6

data/.gitignore

@@ -0,0 +1,5 @@
+Gemfile.lock
+pkg
+.DS_Store
+.ruby-version
+tmp

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fjords.gemspec
+gemspec
+
+group :development do
+  gem "rake"
+  gem "rspec"
+  gem "webmock"
+end

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+desc "Run RSpec"
+RSpec::Core::RakeTask.new do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--color', '--format nested']
+end
+
+desc "Run tests"
+task :test => [:spec]

data/fjords-client.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/fjords-client/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Thomas Reynolds"]
+  gem.email         = ["me@tdreyno.com"]
+  gem.description   = %q{Fjords.cc API}
+  gem.summary       = %q{Fjords.cc API}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "fjords-client"
+  gem.require_paths = ["lib"]
+  gem.version       = Fjords::Client::VERSION
+
+  gem.add_dependency("rest-client", "1.6.7")
+  gem.add_dependency("addressable", "2.3.2")
+  gem.add_dependency("stripe")
+end

data/lib/fjords-client/fjords-client.rb

@@ -0,0 +1,391 @@
+require 'json'
+require 'rest_client'
+require 'addressable/uri'
+require 'tmpdir'
+require 'digest/md5'
+require 'pathname'
+
+require "stripe"
+Stripe.api_key = 'pk_vfcVMdOHZGAFgqLGSEtlSKzsXeBYI'
+
+module Fjords
+  class Token
+    attr_reader :token
+
+    def initialize(token)
+      @token = token
+    end
+  end
+
+  class Client
+
+    EXCLUSION_GLOBS = ['..', '.', '*~', '#*#', '.*', '*/.*']
+
+    class << self
+      attr_accessor :host
+
+      def shared
+        @_shared_client ||= new
+      end
+
+      def host
+        @_host ||= "https://api.fjords.cc/v1"
+      end
+
+      def host=(host)
+        @_host = host
+      end
+    end
+
+    # Delegate methods
+    [
+      :login,
+      :logged_in?,
+      :push,
+      :prepare_push,
+      :sites,
+      :delete_site,
+      :signup,
+      :username_available?,
+      :get_stripe_token,
+      :logout,
+      :validate_domain,
+      :bugreport,
+      :info
+    ].each do |method|
+      module_eval(%Q{
+        def self.#{method}(*args, &block)            # def self.login(*args, &block)
+          shared.__send__(:#{method}, *args, &block) #   shared.__send__(:login, *args, &block)
+        end                                          # end
+      })
+    end
+
+    class ClientError < RuntimeError
+      def initialize(e=nil)
+        super()
+
+        @e = e
+      end
+
+      def report_data
+        @e.backtrace
+      end
+    end
+    class Forbidden < ClientError; end
+    class ConnectionRefused < ClientError; end
+    class ResourceNotFound < ClientError; end
+    class LoginInvalid < ClientError; end
+    class NotAuthorizedError < ClientError; end
+    class InternalServerError < ClientError; end
+    class BadPathError < ClientError; end
+    class Conflict < ClientError; end
+    class UploadTooLarge < ClientError; end
+    class NothingToUpload < ClientError; end
+
+    attr_reader :username
+
+    def logged_in?
+      read_token
+    end
+
+    def signup(email, username, password, stripe_token)
+      json = post("/accounts", {
+        :email => email,
+        :username => username,
+        :password => password,
+        :stripe_token => stripe_token
+      })
+
+      token = json['token']
+
+      store_token(token)
+
+      Token.new(token)
+    end
+
+    def get_stripe_token(name_on_card, number, exp_month, exp_year, cvc)
+      Stripe::Token.create(
+        :card => {
+          :name => name_on_card,
+          :number => number.to_s,
+          :exp_month => exp_month.to_i,
+          :exp_year => exp_year.to_i,
+          :cvc => cvc.to_i
+        }
+      )
+    end
+
+    def login(username, password)
+      json = post("/login", { :username => username, :password => password })
+      token = json['token']
+      store_token(token)
+      Token.new(token)
+    end
+
+    def info
+      json = get("/info")
+      json
+    end
+
+    def logout
+      remove_token
+    end
+
+    def username_available?(username)
+      get("/users/#{username}")
+      false
+    rescue ResourceNotFound
+      true
+    end
+
+    def validate_domain(domain)
+      post("/site_available", {
+        :domain => domain
+      })
+    rescue Conflict
+      false
+    end
+
+    def delete_site(domain_name)
+      json = delete("/sites", :domain => domain_name)
+      !!json["site"]
+    end
+
+    def prepare_push(path, checksums=nil, domain_file="Fjordsfile")
+      raise BadPathError.new unless File.exists?(path) && File.directory?(path)
+
+      if checksums && checksums["site"] && checksums["site"]["existing_hashes"]
+        existing_hashes = checksums["site"]["existing_hashes"]
+      end
+
+      zipfile, changeless = zip!(path, domain_file, existing_hashes || nil)
+      upload_size = File.size(zipfile)
+
+      if upload_size > (1024*1024*50)
+        raise UploadTooLarge.new
+      end
+
+      if upload_size > 1024*1024
+        upload_size  = (upload_size/(1024.0*1024.0)).ceil.to_s + 'M'
+      elsif upload_size > 0
+        upload_size  = (upload_size/1024.0).ceil.to_s + 'K'
+      else
+        upload_size = '0K'
+      end
+
+      [zipfile, changeless, upload_size]
+    end
+
+    def push(zipfile, changeless=[], domain=nil, permanent=nil, &block)
+      raise BadPathError.new unless File.exists?(zipfile)
+
+      data = {
+        :site_data => File.new(zipfile, 'rb'),
+        :changeless => changeless
+      }
+      data[:domain] = domain if domain
+      data[:permanent] = permanent if permanent
+      
+      json = post("/sites", data)
+
+      wait_until_complete(json['site'], &block)
+    end
+
+    def wait_until_complete(site, &block)
+      sleep(3)
+
+      json = get(site["url"])
+
+      block.call(json['site']) if block_given?
+
+      state = json['site']['state']
+
+      if state != "live"
+        wait_until_complete(site, &block)
+      else
+        json
+      end
+    end
+
+    def sites
+      json = get("/sites")
+      json['sites']
+    end
+
+    def bugreport(body, attach=nil)
+      params = { :body => body }
+      if attach
+        params[:attach] = File.new(attach, 'r')
+      end
+
+      json = post("/bugreport", params)
+      json['bugreport']
+    end
+
+  private
+
+    def get_file_paths(path)
+      Dir.glob("#{path}/**/*").reject do |f|
+        !File.file?(f) || EXCLUSION_GLOBS.any? do |e|
+          File.fnmatch(e, File.basename(f))
+        end
+      end
+    end
+
+    def zip!(path, domain_file, existing_hashes=nil)
+      excludes = EXCLUSION_GLOBS.dup
+      excludes << "#{domain_file}"
+      excludes << "*/#{domain_file}"
+      zipfile = File.expand_path(File.join(Dir.tmpdir, "pack-#{Time.now.to_i}.zip"))
+      changeless = []
+
+      if existing_hashes
+        all_files = get_file_paths(path)
+        unique_files = all_files.dup
+
+        all_files.each do |p|
+          relative_path = Pathname(p).relative_path_from(Pathname(path)).to_s
+          if relative_path == domain_file
+            unique_files.delete(p)
+          elsif existing_hashes[relative_path] == get_md5(p)
+            excludes << relative_path
+            changeless << relative_path
+            unique_files.delete(p)
+          end
+        end
+
+        if unique_files.length <= 0
+          raise NothingToUpload
+        end
+      end
+
+      zip_excludes = excludes.map { |e| "-x \"#{e}\"" }.join(' ')
+
+      Dir.chdir(path) do
+        puts `zip -y -q -r #{zipfile} . #{zip_excludes}`
+      end
+
+      [zipfile, changeless]
+    end
+
+    def require_login!
+      raise NotAuthorizedError unless @user || logged_in?
+    end
+
+    def path(resource_name)
+      "#{self.class.host}#{resource_name}"
+    end
+
+    def get_md5(path)
+      digest = ::Digest::MD5.new
+
+      ::File.open(path, 'rb') do |stream|
+        buffer = ""
+        digest.update(buffer) while stream.read(4096, buffer)
+      end
+
+      digest.to_s
+    end
+
+    def get(resource_path, extra_headers={})
+      request(:get, resource_path, nil, extra_headers)
+    end
+
+    def post(resource_path, params={}, extra_headers={})
+      request(:post, resource_path, params, extra_headers)
+    end
+
+    def delete(resource_path, params={}, extra_headers={})
+      request(:delete, resource_path, params, extra_headers)
+    end
+
+    def safe_url(url)
+      url = path(url)
+      Addressable::URI.parse(url).normalize.to_str
+    end
+
+    def request(type, url, params=nil, extra_headers={})
+      headers = {
+        :accept => :json
+      }
+
+      token = self.logged_in?
+      headers[:authorization] = %Q{Token token="#{token.token}"} if token
+
+      headers.merge!(extra_headers)
+
+      req = {
+        :method  => type.to_sym,
+        :url     => safe_url(url),
+        :headers => headers
+      }
+      req[:payload] = params unless params.nil?
+
+      begin
+        response = RestClient::Request.execute(req)
+        headers[:accept] == :json ? JSON.parse(response) : response
+      rescue RestClient::InternalServerError => e
+        raise InternalServerError.new(e)
+      rescue RestClient::ServerBrokeConnection => e
+        raise InternalServerError.new(e)
+      rescue RestClient::ResourceNotFound => e
+        raise ResourceNotFound.new(e)
+      rescue RestClient::Unauthorized => e
+        raise LoginInvalid.new(e)
+      rescue RestClient::Conflict => e
+        raise Conflict.new(e)
+      rescue RestClient::Forbidden => e
+        raise Forbidden.new(e)
+      rescue Errno::ECONNREFUSED => e
+        raise ConnectionRefused.new(e)
+      rescue Exception => e
+        raise ConnectionRefused.new(e)
+      end
+    end
+
+    TOKEN_FILE_PATH = "~/.fjords_token"
+
+    def read_token
+      return @token if @token
+
+      token_file = File.expand_path(TOKEN_FILE_PATH)
+
+      return nil unless File.exists?(token_file)
+
+      @token = Token.new(read_file(token_file).strip)
+    end
+
+    def remove_token
+      path = File.expand_path(TOKEN_FILE_PATH)
+      if File.exists?(path)
+        FileUtils.rm(path)
+      end
+    end
+
+    def store_token(token)
+      token_file = File.expand_path(TOKEN_FILE_PATH)
+      write_file(token_file, token)
+      read_token
+    end
+
+    def read_file(file)
+      File.open(file, File::RDONLY) {|f|
+        f.flock(File::LOCK_EX)
+        contents = f.read
+        f.flock(File::LOCK_UN)
+        contents
+      }
+    end
+
+    def write_file(file, contents)
+      File.open(file, File::RDWR | File::CREAT, 0600) {|f|
+        f.flock(File::LOCK_EX)
+        f.rewind
+        f.puts contents
+        f.flush
+        f.truncate(f.pos)
+        f.flock(File::LOCK_UN)
+      }
+    end
+  end
+end

data/lib/fjords-client/version.rb

@@ -0,0 +1,5 @@
+module Fjords
+  class Client
+    VERSION = "0.0.6"
+  end
+end

data/lib/fjords-client.rb

@@ -0,0 +1,4 @@
+FJORDS_CLIENT_ROOT = File.join(File.expand_path(File.dirname(__FILE__)), 'fjords-client')
+
+require "#{FJORDS_CLIENT_ROOT}/fjords-client"
+require "#{FJORDS_CLIENT_ROOT}/version"

data/spec/logged_in_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe "Site listing" do
+  before(:each) do 
+    stub_request(:post, "https://api.fjords.cc/v1/users/testy/login").
+      with(:body => {"password"=>"wrong"}).
+      to_return(:status => 401, :body => "")
+
+    stub_request(:post, "https://api.fjords.cc/v1/users/testy/login").
+      with(:body => {"password"=>""}).
+      to_return(:status => 401, :body => "")
+
+    stub_request(:post, "https://api.fjords.cc/v1/users/testy/login").
+      with(:body => {"password"=>"mcgee"}).
+      to_return(:status => 200, :body => {
+        :account => { :username => "testy" },
+        :token => "tokenkey"
+      }.to_json)
+  end
+
+  it "should be false when not logged in" do
+    Fjords::Client.logged_in?.should be_false
+  end
+
+  it "should catch login invalid error with missing password" do
+    expect {
+      Fjords::Client.login("testy", "")
+    }.to raise_error(Fjords::Client::LoginInvalid)
+    WebMock.should have_requested(:post, "https://api.fjords.cc/v1/users/testy/login").with({ :body =>{"password"=>""} })
+  end
+
+  it "should catch login invalid error with wrong password" do
+    expect {
+      Fjords::Client.login("testy", "wrong")
+    }.to raise_error(Fjords::Client::LoginInvalid)
+    WebMock.should have_requested(:post, "https://api.fjords.cc/v1/users/testy/login").with({ :body =>{"password"=>"wrong"} })
+  end
+
+  it "should be true when a token exists" do
+    Fjords::Client.login("testy", "mcgee")
+    WebMock.should have_requested(:post, "https://api.fjords.cc/v1/users/testy/login").with({ :body =>{"password"=>"mcgee"} })
+
+    Fjords::Client.logged_in?.should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rspec'
+require 'webmock/rspec'
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib', 'fjords-client')
+
+require 'fjords-client'
+
+RSpec.configure do |conf|
+  conf.include WebMock::API
+  conf.include WebMock::Matchers
+
+  conf.before(:all) do
+    Fjords::Client.logout
+    # Fjords::Client.host = "https://fake.fjords.cc/v1"
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: fjords-client
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Reynolds
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+- !ruby/object:Gem::Dependency
+  name: stripe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fjords.cc API
+email:
+- me@tdreyno.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- fjords-client.gemspec
+- lib/fjords-client.rb
+- lib/fjords-client/fjords-client.rb
+- lib/fjords-client/version.rb
+- spec/logged_in_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1471701448195210841
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1471701448195210841
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Fjords.cc API
+test_files:
+- spec/logged_in_spec.rb
+- spec/spec_helper.rb