staticdctl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a564980b186b0e719ec4b76086f6d79866c8493a
+  data.tar.gz: a154b91cbf0b56568a7a63590ace9b4e5f1be233
+SHA512:
+  metadata.gz: 5e3b3d231e138732158caf657cf2b755709cc4fa310937cf214d5abf8636ac8c2cc80a511dea7426621ecf6a8b1b7a48745bbbba68cf772452e418f3bd466464
+  data.tar.gz: 60087771fcedfc6be518eb400289a3bfab1999a47ad393f2418046d18a12846ef24f010141b18b81590420551a427a41cfe44c3551a519130c0304879a94a2b2

data/bin/staticdctl

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'staticdctl/cli'
+
+debugging = (ARGV.include?("--debug") || ARGV.include?("-d"))
+cli = Staticdctl::CLI.new(debugging: debugging)
+exit cli.run(ARGV)

data/lib/staticd_utils/archive.rb

@@ -0,0 +1,80 @@
+require "zlib"
+require "base64"
+require "open-uri"
+require "staticd_utils/memory_file"
+require "staticd_utils/tar"
+
+module StaticdUtils
+
+  # Manage Staticd archives.
+  #
+  # This class can manage the archives used as transport package to transfer
+  # files beetween Staticd client and Staticd API.
+  class Archive
+    attr_reader :stream
+
+    def self.open_file(url)
+      new(open(url))
+    end
+
+    # Create an archive from a folder.
+    #
+    # Can include a manifest as an array of files full path (from directory path
+    # as root).
+    #
+    # Example:
+    #   StaticdUtils::Archive.create("/tmp/my_site", ["/index.html"])
+    #   # Only the /tmp/my_site/index.html file will be included into
+    #     the archive.
+    def self.create(directory_path, manifest=nil)
+      files =
+        if manifest
+          manifest.map { |entry| directory_path + entry }
+        else
+          Dir["#{directory_path}/**/*"].select { |f| File.file?(f) }
+        end
+      new(Tar.tar(files))
+    end
+
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def open
+      Dir.mktmpdir do |tmp|
+        Dir.chdir(tmp) do
+          extract(tmp)
+          yield tmp
+        end
+      end
+    end
+
+    def close
+      @stream.close unless @stream.closed?
+    end
+
+    def extract(path)
+      return false if @stream.closed?
+
+      Tar.untar(@stream, path)
+      close
+      path
+    end
+
+    def size
+      @stream.size
+    end
+
+    def to_file(path)
+      return false if @stream.closed?
+
+      File.open(path, 'w') { |file| file.write(@stream.read) }
+      self.close
+      path
+    end
+
+    def to_memory_file
+      StaticdUtils::MemoryFile.new(@stream)
+    end
+  end
+end

data/lib/staticd_utils/file_size.rb

@@ -0,0 +1,26 @@
+module StaticdUtils
+
+  # Class to convert file size in octect to human readable size.
+  #
+  # Example:
+  #   Staticd::FileSize.new(1000).to_s
+  #   # => "1KB"
+  class FileSize
+
+    def initialize(size)
+      @size = size
+    end
+
+    def to_s
+      units = %w(B KB MB GB TB)
+      base = 1000
+      return "#{@size}#{units[0]}" if @size < base
+
+      exponent = (Math.log(@size) / Math.log(base)).to_i
+      exponent = units.size - 1 if exponent > units.size - 1
+
+      human_size = @size / base**exponent
+      "#{human_size}#{units[exponent]}"
+    end
+  end
+end

data/lib/staticd_utils/gli_object.rb

@@ -0,0 +1,14 @@
+require "gli"
+
+# Move the GLI::App module into its own class.
+#
+# It's usefull to build a GLI::App like object.
+#
+# Example:
+#   gli = GLIObject.new
+#   gli.program_desc("My Ultimate CLI")
+#   gli.version("1.0")
+#   gli.run(*args)
+class GLIObject
+  include GLI::App
+end

data/lib/staticd_utils/memory_file.rb

@@ -0,0 +1,36 @@
+module StaticdUtils
+
+  # Make an IO object behave like File objects.
+  #
+  # Example:
+  #   io = StringIO.new("Content")
+  #   file = MemoryFile.new(io)
+  #   file.read
+  #   # => "Content"
+  #   file.path
+  #   # => "memory_file"
+  #   file.content_type
+  #   # => "application/octet-stream"
+  class MemoryFile
+
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def read(*args)
+      @stream.read(*args)
+    end
+
+    def path
+      original_filename
+    end
+
+    def original_filename
+      "memory_file"
+    end
+
+    def content_type
+      "application/octet-stream"
+    end
+  end
+end

data/lib/staticd_utils/sitemap.rb

@@ -0,0 +1,100 @@
+require "digest/sha1"
+require "yaml"
+require "staticd_utils/memory_file"
+
+module StaticdUtils
+
+  # Manifest for Staticd releases.
+  #
+  # A Sitemap consist of an associative array representing each resources of a
+  # site release. Each entry consist of the sha1 digest of the resource content
+  # and the complete HTTP path this resource must be available to.
+  #
+  # Example:
+  #   sitemap = StaticdUtils::Sitemap.create("/tmp/my_website")
+  #   sitemap.to_h
+  #   # => {
+  #          "058ec3fa8aab4c0ccac27d80fd24f30a8730d3f6"=>"/index.html",
+  #          "92136ff551f50188f46486ab80db269eda4dfd4e"=>"/hello/world.html"
+  #        }
+  class Sitemap
+
+    # Create a sitemap from a directory content.
+    #
+    # It register each files digest and path inside the sitemap.
+    def self.create(path)
+      map = {}
+      if File.directory?(path)
+        Dir.chdir(path) do
+          Dir["**/*"].each do |object|
+            if File.file?(object)
+              sha1 = Digest::SHA1.hexdigest(File.read(object))
+              map[sha1] = "/#{object}"
+            end
+          end
+        end
+      end
+      new(map)
+    end
+
+    # Create a sitemap from a YAML string.
+    #
+    # The YAML string must reflect the sitemap associative array structure.
+    #
+    # Example:
+    #   yaml = "---\n058ec3fa8aab4c0ccac27d80fd24f30a8730d3f6: \"/hi.html\"\n"
+    #   sitemap = StaticdUtils::Sitemap.open(yaml)
+    def self.open(yaml)
+      new(YAML.load(yaml))
+    end
+
+    # Create a sitemap from a YAML file.
+    #
+    # The YAML file must reflect the sitemap associative array structure.
+    def self.open_file(path)
+      open(File.read(path))
+    end
+
+    # Create a sitemap from an associative array.
+    #
+    # The associative array must have the folowing structure:
+    # * Key: the sha1 of the ressource
+    # * Value: the HTTP path of the resource
+    #
+    # Example:
+    #   sitemap = Sitemap.new({
+    #     058ec3fa8aab4c0ccac27d80fd24f30a8730d3f6: "hi.html"
+    #   })
+    def initialize(map)
+      @map = map
+    end
+
+    # View all HTTP path of the sitemap.
+    def routes
+      @map.map { |sha1, path| path }
+    end
+
+    # View all sha1 digest of the sitemap.
+    def digests
+      @map.map { |sha1, path| sha1 }
+    end
+
+    # Iterate over each resources of the sitemap.
+    def each_resources
+      @map.each { |sha1, path| yield sha1, path }
+    end
+
+    def to_h
+      @map
+    end
+
+    def to_yaml
+      @map.to_yaml
+    end
+
+    # Export the sitemap to a YAML file stored into memory.
+    def to_memory_file
+      StaticdUtils::MemoryFile.new(StringIO.new(to_yaml))
+    end
+  end
+end

data/lib/staticd_utils/tar.rb

@@ -0,0 +1,43 @@
+require "rubygems/package"
+require "digest/sha1"
+
+module StaticdUtils
+
+  # Creation and Extraction of Tarball Stream.
+  #
+  # Example:
+  #  tar = Tar.tar(["/tmp/hello"])
+  #  Tar.untar(tar, "/tmp")
+  class Tar
+
+    def self.tar(files)
+      io = StringIO.new
+      tar = Gem::Package::TarWriter.new(io)
+
+      # Gem::Package::TarReader raise an exeption extracting an empty tarball,
+      # this add at least one useless file to extract.
+      tar.add_file("about", 0644) { |file| file.write("Hello.") }
+
+      files.each do |file|
+        content = File.read(file)
+        sha1 = Digest::SHA1.hexdigest(content)
+        tar.add_file(sha1, 0644) { |entry| entry.write(content) }
+      end
+
+      io.rewind
+      io
+    end
+
+    def self.untar(io, path)
+      FileUtils.mkdir_p("#{path}")
+      tar = Gem::Package::TarReader.new(io)
+      tar.rewind
+      tar.each do |entry|
+        File.open("#{path}/#{entry.full_name}", "w+") do |file|
+          file.write(entry.read)
+        end
+      end
+      tar.close
+    end
+  end
+end

data/lib/staticdctl.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/staticdctl/**/*.rb"].each do |library|
+  require library
+end

data/lib/staticdctl/cli.rb

@@ -0,0 +1,330 @@
+require "digest/sha1"
+require "staticdctl"
+require "yaml"
+require "staticd_utils/gli_object"
+require "staticd_utils/archive"
+require "staticd_utils/sitemap"
+require "staticd_utils/file_size"
+
+module Staticdctl
+  class CLI
+
+    def initialize(options={})
+      @gli = GLIObject.new
+      @gli.program_desc("Staticd CLI client")
+      @gli.version(Staticdctl::VERSION)
+
+      enable_debugging if options[:debugging]
+      set_global_options
+      build_commands
+    end
+
+    def run(*args)
+      @gli.run(*args)
+    end
+
+    private
+
+    def enable_debugging
+      @gli.on_error { |exception| raise exception }
+    end
+
+    def load_global_config(config_file)
+      YAML.load_file(config_file)
+    rescue
+      {}
+    end
+
+    def load_config(config_file, host)
+      config = load_global_config(config_file)
+      config && config.has_key?(host) ? config[host] : {}
+    end
+
+    def staticd_client(options)
+      config = load_config(options[:config], options[:host])
+      client = Staticdctl::StaticdClient.new(
+        options[:host],
+        access_id: config["access_id"],
+        secret_key: config["secret_key"]
+      )
+      yield client
+    end
+
+    def set_global_options
+      set_global_option_config
+      set_global_option_host
+      set_global_option_site
+      set_global_option_debug
+    end
+
+    def set_global_option_config
+      @gli.desc("Staticd configuration file")
+      @gli.default_value("#{ENV['HOME']}/.staticdctl.yml")
+      @gli.arg_name("<Staticd configuration file>")
+      @gli.flag([:c, :config])
+    end
+
+    def set_global_option_host
+      @gli.desc("Staticd API endpoint")
+      @gli.default_value(
+        ENV["STATICDCTL_ENDPOINT"] || "http://localhost/api/v1"
+      )
+      @gli.arg_name("<Staticd API endpoint>")
+      @gli.flag([:h, :host])
+    end
+
+    def set_global_option_site
+      @gli.desc("Site name")
+      @gli.default_value(File.basename(Dir.pwd))
+      @gli.arg_name("<Site name>")
+      @gli.flag([:s, :site])
+    end
+
+    def set_global_option_debug
+      @gli.desc("Enable debugging (raise exception on error)")
+      @gli.default_value(false)
+      @gli.arg_name("debug")
+      @gli.switch([:d, :debug])
+    end
+
+    def build_commands
+      build_command_config
+      build_command_set_config
+      build_command_rm_config
+      build_command_sites
+      build_command_create_site
+      build_command_destroy_site
+      build_command_domains
+      build_command_attach_domain
+      build_command_detach_domain
+      build_command_releases
+      build_command_create_release
+    end
+
+    def build_command_config
+      @gli.desc("Display current configuration")
+      @gli.command(:config) do |c|
+        c.action do |global_options, options, args|
+          config = load_config(global_options[:config], global_options[:host])
+          puts "Current configuration for #{global_options[:host]}:"
+          puts "No config." unless config.any?
+          config.each do |key, value|
+            puts " * #{key}: #{value}"
+          end
+        end
+      end
+    end
+
+    def build_command_set_config
+      @gli.desc("Set a configuration option")
+      @gli.arg_name("config_key")
+      @gli.command(:"config:set") do |c|
+        c.action do |global_options, options, args|
+          global_config = load_global_config(global_options[:config])
+          global_config[global_options[:host]] ||= {}
+          global_config[global_options[:host]][args[0]] = args[1]
+          File.open(global_options[:config], 'w+') do |file|
+            file.write(global_config.to_yaml)
+            puts "The #{args[0]} config key has been set to #{args[1]}."
+          end
+        end
+      end
+    end
+
+    def build_command_rm_config
+      @gli.desc("Remove a configuration option")
+      @gli.arg_name("config_key")
+      @gli.command(:"config:rm") do |c|
+        c.action do |global_options, options, args|
+          global_config = load_global_config(global_options[:config])
+
+          unless (
+            global_config.has_key?(global_options[:host]) &&
+            global_config[global_options[:host]].has_key?(args.first)
+          ) then
+            puts "The #{args.first} config key cannot be found."
+          end
+
+          global_config[global_options[:host]].delete(args.first)
+          File.open(global_options[:config], 'w+') do |file|
+            file.write(global_config.to_yaml)
+            puts "The #{args.first} config key has been removed."
+          end
+        end
+      end
+    end
+
+    def build_command_sites
+      @gli.desc("List all sites")
+      @gli.command(:sites) do |c|
+        c.action do |global_options,options,args|
+          staticd_client(global_options) do |client|
+            client.sites do |sites|
+              puts "Sites hosted on #{global_options[:host]}:"
+              puts "No sites yet." unless sites.any?
+              sites.each do |site|
+                last_release = site.releases.last
+                last_release_string = last_release ? last_release.tag : "-"
+                domains =
+                  site.domain_names.map{ |domain| domain.name }.join(", ")
+                domains_string = domains.empty? ? "no domains" : domains
+                puts " * #{site.name} (#{last_release_string}): #{site.url}"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def build_command_create_site
+      @gli.desc("Create a new site")
+      @gli.command(:"sites:create") do |c|
+        c.action do |global_options,options,args|
+          staticd_client global_options do |client|
+            client.create_site(name: global_options[:site]) do |site|
+              puts "The #{site.name} site has been created."
+              puts site.url if site.url
+            end
+          end
+        end
+      end
+    end
+
+    def build_command_destroy_site
+      @gli.desc("Destroy a site")
+      @gli.command(:"sites:destroy") do |c|
+        c.action do |global_options,options,args|
+          staticd_client(global_options) do |client|
+            client.destroy_site(global_options[:site]) do
+              puts "The #{global_options[:site]} site has been destroyed."
+            end
+          end
+        end
+      end
+    end
+
+    def build_command_domains
+      @gli.desc("List all domain attached to the current site")
+      @gli.command :domains do |c|
+        c.action do |global_options,options,args|
+          staticd_client(global_options) do |client|
+            client.domains(global_options[:site]) do |domains|
+              puts "Domain names attached to #{global_options[:site]}:"
+              puts "No domain names attached." unless domains.any?
+              domains.each do |domain|
+                puts " * #{domain.name}"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def build_command_attach_domain
+      @gli.desc("Attach a domain name to a site")
+      @gli.arg_name("domain_name")
+      @gli.command(:"domains:attach") do |c|
+        c.action do |global_options,options,args|
+          staticd_client(global_options) do |client|
+            client.attach_domain(
+              global_options[:site],
+              name: args.first
+            ) do |domain|
+              puts "The #{domain.name} domain has been attached to the " +
+                "#{domain.site_name} site."
+            end
+          end
+        end
+      end
+    end
+
+    def build_command_detach_domain
+      @gli.desc("Detach a domain name from a site")
+      @gli.arg_name("domain_name")
+      @gli.command(:"domains:detach") do |c|
+        c.action do |global_options,options,args|
+          staticd_client(global_options) do |client|
+            client.detach_domain(global_options[:site], args.first) do |domain|
+              puts "The #{args.first} domain has been detached from the " +
+                "#{global_options[:site]} site."
+            end
+          end
+        end
+      end
+    end
+
+    def build_command_releases
+      @gli.desc("List all releases of the current site")
+      @gli.command(:releases) do |c|
+        c.action do |global_options,options,args|
+          staticd_client(global_options) do |client|
+            client.releases(global_options[:site]) do |releases|
+              releases_string =
+                if releases.any?
+                  releases.map { |release| release.tag }.join(", ")
+                else
+                  "no release deployed yet"
+                end
+              puts "Releases of #{global_options[:site]}: #{releases_string}."
+            end
+          end
+        end
+      end
+    end
+
+    def build_command_create_release
+      @gli.desc("Push a new release for the current app")
+      @gli.arg_name("[path]")
+      @gli.command(:push) do |c|
+        c.action do |global_options,options,args|
+          source_path = args.any? ? args.first : "."
+
+          print "Counting resources... "
+          sitemap = StaticdUtils::Sitemap.create(source_path)
+          if sitemap.routes.size < 1
+            puts "stop. No resources."
+            raise "No resources to send in '#{source_path}'"
+          end
+          puts "done (#{sitemap.routes.size} resources)."
+
+          print "Asking host to identify new resources... "
+          diff_sitemap = staticd_client(global_options) do |client|
+            client.cached_resources(sitemap.to_h) do |new_map|
+              StaticdUtils::Sitemap.new(new_map.to_h)
+            end
+          end
+          puts "done (#{diff_sitemap.routes.size} new resources to upload)."
+
+          print "Building the archive... "
+          archive = StaticdUtils::Archive.create(
+            source_path,
+            diff_sitemap.routes
+          )
+          file_size = StaticdUtils::FileSize.new(archive.size)
+          puts "done (#{file_size})."
+
+          staticd_client(global_options) do |client|
+
+            print "Uploading the archive... "
+            timer_start = Time.now
+            client.create_release(
+              global_options[:site],
+              archive.to_memory_file,
+              sitemap.to_memory_file
+            ) do |release|
+              time_spent = Time.now - timer_start
+              speed = archive.size / time_spent / 1000
+              puts "done (#{'%.2f' % time_spent}s / #{'%.2f' % speed}kbps)."
+              puts ""
+              puts "The #{release.site_name} release (#{release.tag}) has " +
+                  "been created."
+              if release.site.url
+                puts release.site.url
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/staticdctl/rest_client.rb

@@ -0,0 +1,87 @@
+require "rest_client"
+require "api-auth"
+require "json"
+
+module Staticdctl
+
+  # Simple REST client library with HMAC authentication.
+  #
+  # Support for remote call on JSON REST API.
+  #
+  # Example:
+  #   client = Staticdctl::RESTCLient.new(
+  #     url: "http://api.domain.tld/v1",
+  #     access_id: 1000,
+  #     secret_key: "youshallnotpass"
+  #   )
+  #   client.call(:get, "/resources") { |response| puts response }
+  class RESTClient
+
+    def initialize(url, hmac={})
+      @url = url
+      @access_id = hmac[:access_id] || ""
+      @secret_key = hmac[:secret_key] || ""
+    end
+
+    # Call a remote REST API action.
+    #
+    # Example:
+    #   client.call(:post, "/posts", {text: "hello_world"}) do |response|
+    #     puts response
+    #   end
+    def call(method, path, req_data=nil, &block)
+      headers = {
+        "Accept" => "application/json"
+      }
+      headers["Content-Type"] = "application/json" if req_data
+      payload = req_data ? req_data.to_json : nil
+      request = RestClient::Request.new(
+        url: @url + path,
+        method: method,
+        headers: headers,
+        payload: payload
+      )
+      send_request(request, block)
+    end
+
+    # Send files using the HTTP multipart/form-data content-type.
+    #
+    # Example:
+    #   client.send_files("/attachments", {first: file1, second: file2})
+    def send_files(path, files, &block)
+      headers = {
+       "Accept" => "application/json",
+       "Content-Type" => "multipart/form-data"
+      }
+      request = RestClient::Request.new(
+        url: @url + path,
+        method: :post,
+        headers: headers,
+        payload: files,
+        timeout: -1
+      )
+      send_request(request, block)
+    end
+
+    private
+
+    def send_request(request, block)
+      signed_request = ApiAuth.sign!(request, @access_id, @secret_key)
+      signed_request.execute do |response, request, result|
+        res_data = JSON.parse(response.to_s) unless response.to_s.empty?
+        case response.code
+        when 200
+          block.call(res_data)
+        when 204
+          block.call
+        when 403
+          raise res_data["error"]
+        when 401
+          raise res_data["error"]
+        else
+          raise "Server returned an '#{response.code}' status code."
+        end
+      end
+    end
+  end
+end

data/lib/staticdctl/staticd_client.rb

@@ -0,0 +1,119 @@
+require "staticdctl/rest_client"
+
+module Staticdctl
+
+  # Class to interact with the Staticd API.
+  #
+  # Example:
+  #   staticd_client = Staticdctl::StaticdClient.new(
+  #     url: "http://staticd.domain.tld/api",
+  #     access_id: ENV["STATICD_ACCESS_ID"],
+  #     secret_key: ENV["STATICD_SECRET_KEY"]
+  #   )
+  class StaticdClient
+
+    def initialize(url, hmac={})
+      url = url
+      access_id = hmac[:access_id] || ""
+      secret_key = hmac[:secret_key] || ""
+      @staticd_api = Staticdctl::RESTClient.new(
+        url,
+        access_id: access_id,
+        secret_key: secret_key
+      )
+    end
+
+    def sites
+      @staticd_api.call(:get, "/sites") do |data|
+        yield build_response(data)
+      end
+    end
+
+    def create_site(site_params)
+      @staticd_api.call(:post, "/sites", site_params) do |data|
+        yield build_response(data)
+      end
+    end
+
+    def destroy_site(site_name)
+      @staticd_api.call(:delete, "/sites/#{site_name}") do
+        yield
+      end
+    end
+
+    def domains(site_name)
+      @staticd_api.call(:get, "/sites/#{site_name}/domain_names") do |data|
+        yield build_response(data)
+      end
+    end
+
+    def attach_domain(site_name, domain_params)
+      @staticd_api.call(
+        :post,
+        "/sites/#{site_name}/domain_names",
+        domain_params
+      ) do |data|
+        yield build_response(data)
+      end
+    end
+
+    def detach_domain(site_name, domain_name)
+      @staticd_api.call(
+        :delete,
+        "/sites/#{site_name}/domain_names/#{domain_name}"
+      ) do
+        yield
+      end
+    end
+
+    def releases(site_name)
+      @staticd_api.call :get, "/sites/#{site_name}/releases" do |data|
+        yield build_response(data)
+      end
+    end
+
+    def create_release(site_name, archive_file, sitemap_file)
+      @staticd_api.send_files(
+        "/sites/#{site_name}/releases",
+        {file: archive_file, sitemap: sitemap_file}
+      ) do |data|
+        yield build_response(data)
+      end
+    end
+
+    # Parse a sitemap of resources digest and return of sitemap purged of
+    # already know resources.
+    #
+    # Submit a list of resources sha1 digests with HTTP path (in the sitemap
+    # format) and get a list purged of already known resources (resources
+    # already stored in database).
+    def cached_resources(digests)
+      @staticd_api.call(:post, "/resources/get_cached", digests) do |data|
+        yield build_response(data)
+      end
+    end
+
+    private
+
+    def build_response(data)
+      data.kind_of?(Array) ? build_collection(data) : build_object(data)
+    end
+
+    def build_collection(data)
+      data.map { |element| build_object(element) }
+    end
+
+    def build_object(data)
+      struct = OpenStruct.new
+      data.each do |key, value|
+        struct[key] =
+          case
+          when value.kind_of?(Array) then build_collection(value)
+          when value.kind_of?(Hash) then build_object(value)
+          else value
+          end
+      end
+      struct
+    end
+  end
+end

data/lib/staticdctl/version.rb

@@ -0,0 +1,3 @@
+module Staticdctl
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: staticdctl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Etienne Garnier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+- !ruby/object:Gem::Dependency
+  name: rest_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: api-auth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.6
+description: CLI Client for the Staticd API service
+email: garnier.etienne@gmail.com
+executables:
+- staticdctl
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/staticdctl/cli.rb
+- lib/staticdctl/rest_client.rb
+- lib/staticdctl/staticd_client.rb
+- lib/staticdctl/version.rb
+- lib/staticd_utils/memory_file.rb
+- lib/staticd_utils/file_size.rb
+- lib/staticd_utils/sitemap.rb
+- lib/staticd_utils/gli_object.rb
+- lib/staticd_utils/archive.rb
+- lib/staticd_utils/tar.rb
+- lib/staticdctl.rb
+- bin/staticdctl
+homepage: http://staticd.eggnet.io
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Staticd CLI Client
+test_files: []