sant0sk1-dreamy 0.1.1

data/README.md

@@ -0,0 +1,82 @@
+What is it?
+===========
+
+[Dreamy][1] is Ruby library and command line tool for interfacing with [DreamHost's API][2]. The API itself is still very young so this is by no means a comprehensive library. Please fork and contribute!
+
+
+Install
+=======
+
+Grab the gem from GitHub
+
+    gem sources -a http://gems.github.com
+    gem install sant0sk1-dreamy
+
+Library Usage
+=============
+
+DreamHost requires a username (email or webID) and API key (available from your DH Panel) to make API requests. When creating a Dreamy instance you'll need to provide this data. The Dreamy command line tool (dh) gathers the necessary info from a configuration file or environment variables, but you can do it however you'd like.
+
+To get started with the library:
+
+    require 'rubygems'
+    require 'dreamy'
+    
+    account = Dreamy::Control.new(username,api_key)
+    
+    # fetch an array of Dreamy::Domain objects
+    account.domains
+    
+    # fetch an array of Dreamy::User objects
+    account.users
+    
+    # fetch an array of Dreamy::Dns objects
+    account.dns
+    
+Command Line Usage
+==================
+
+The Dreamy gem will install an executable called "dh". In order to use it, you'll need to set your DreamHost account username and API key. You can acquire an API key from the DreamHost panel. "dh" will fetch your API credentials from 2 places, respectively:
+
+1)  A file called .dreamyrc in your $HOME directory with username on line 1, api key on line 2
+
+An example ~/.dreamyrc would look like:
+
+    dh_user@gmail.com
+    34TGGGKBRG3YD1EA
+    
+2) Environment variables DH\_USER and DH\_KEY. You can set these by typing this in your shell:
+
+    export DH_USER=dh_user@gmail.com
+    export DH_KEY=34TGGGKBRG3YD1EA
+    
+If you want to make those environment variables permanent, add those 2 lines to the bottom of your ~/.bashrc
+
+
+Run this from the command line to print the usage:
+
+    dh help
+    
+    === Commands
+
+     help                         # show this usage
+
+     domains                      # list domains
+     domains:status               # check availability of all domains
+
+     dns                          # list your DNS records
+     dns <name>                   # list DNS records for <ame>
+
+     users                        # list user accounts
+     
+That's it for now. New commands should be springing up as Dreamy and the DreamHost API mature!
+
+TODO
+====
+
+* more tests
+* create rdocs
+* mailing lists
+
+[1]:http://github.com/sant0sk1/dreamy
+[2]:http://wiki.Dreamy.com/API

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test_units]
+
+desc "Run basic tests"
+Rake::TestTask.new("test_units") { |t|
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = true
+}
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "dreamy"
+    gemspec.summary = "A Ruby library and command line tool for accessing DreamHost's API"
+    gemspec.email = "jerod.santo@gmail.com"
+    gemspec.homepage = "http://github.com/sant0sk1/dreamy"
+    gemspec.authors = ["Jerod Santo"]
+    gemspec.add_dependency('visionmedia-terminal-table', '>= 1.0.5')
+    gemspec.files.exclude 'test/credentials.yml'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 1
+:major: 0
+:minor: 1

data/bin/dh

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'dreamy'
+require 'dreamy/command'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Dreamy::Command.run(command, args)

data/lib/dreamy.rb

@@ -0,0 +1,19 @@
+require 'uri'
+require 'net/https'
+require 'yaml'
+require 'rubygems'
+require 'hpricot'
+require 'uuid'
+
+
+$:.unshift(File.dirname(__FILE__) + "/dreamy")
+require 'dreamy/easy_class_maker'
+require 'dreamy/control'
+require 'dreamy/domain'
+require 'dreamy/dns'
+require 'dreamy/user'
+
+module Dreamy
+    class CantConnect < StandardError; end
+    class Unavailable < StandardError; end
+end

data/lib/dreamy/command.rb

@@ -0,0 +1,66 @@
+require 'commands/base'
+
+module Dreamy
+  module Command
+    class InvalidCommand < RuntimeError; end
+    class CommandFailed  < RuntimeError; end
+    class Unauthorized   < RuntimeError; end
+
+    class << self
+      def run(command, args, retries=0)
+        run_internal(command, args)
+      rescue InvalidCommand
+        error "Unknown command. Run 'dh help' for usage information."
+      rescue Unauthorized
+        if retries < 3
+          STDERR.puts "Authentication failure"
+          run(command, args, retries+1)
+        else
+          error "Authentication failure"
+        end
+      rescue CommandFailed => e
+        error e.message
+      rescue Interrupt => e
+        error "\n[canceled]"
+      end
+
+      def run_internal(command, args)
+        namespace, command = parse(command)
+        require "commands/#{namespace}"
+        klass = Dreamy::Command.const_get(namespace.capitalize).new(args)
+        raise InvalidCommand unless klass.respond_to?(command)
+        klass.send(command)
+      end
+
+      def error(msg)
+        STDERR.puts(msg)
+        exit 1
+      end
+
+      def parse(command)
+        parts = command.split(':')
+        case parts.size
+        when 1
+          if namespaces.include? command
+            return command, 'index'
+          else
+            raise InvalidCommand
+          end
+        when 2
+          raise InvalidCommand unless namespaces.include? parts[0]
+          return parts
+        else
+          raise InvalidCommand
+        end
+      end
+
+      def namespaces
+        @@namespaces ||= Dir["#{File.dirname(__FILE__)}/commands/*"].map do |namespace|
+          namespace.gsub(/.*\//, '').gsub(/\.rb/, '')
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dreamy/commands/base.rb

@@ -0,0 +1,96 @@
+require 'terminal-table/import'
+
+module Dreamy::Command
+  class Base
+    
+    attr_accessor :args
+    def initialize(args)
+      @args     = args
+      @account  = configure_account 
+    end
+
+    def display(msg, newline=true)
+      if newline
+        puts(msg)
+      else
+        print(msg)
+        STDOUT.flush
+      end
+    end
+
+    def ask
+      gets.strip
+    end
+
+    def shell(cmd)
+      `cd '#{Dir.pwd}' && #{cmd}`
+    end
+
+    def extract_option(options, default=true)
+      values = options.is_a?(Array) ? options : [options]
+      return unless opt_index = args.select { |a| values.include? a }.first
+      opt_position = args.index(opt_index) + 1
+      if args.size > opt_position && opt_value = args[opt_position]
+        if opt_value.include?('--')
+          opt_value = nil
+        else
+          args.delete_at(opt_position)
+        end
+      end
+      opt_value ||= default
+      args.delete(opt_index)
+      block_given? ? yield(opt_value) : opt_value
+    end
+
+    def home_directory
+      running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+    end
+
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32/
+    end
+    
+    private
+    
+    def configure_account
+			Dreamy::Control.new(user,key)
+    end
+    
+    def user
+      get_credentials
+      @credentials[0]
+    end
+    
+    def key
+      get_credentials
+      @credentials[1]
+    end
+    
+    def credentials_file
+			"#{home_directory}/.dreamyrc"
+		end
+		
+		def read_credentials
+		  if File.exists? credentials_file
+				return File.read(credentials_file).split("\n")
+			end
+		end
+    
+    def get_credentials
+      return if @credentials
+      unless @credentials = read_credentials
+        @credentials = [ENV['DH_USER'], ENV['DH_KEY']]
+      end
+      if @credentials[0].nil? || @credentials[1].nil?
+        display "\nYou need to set your API credentials. You can do this 2 ways:\n"
+        display "\n1) set environment variables 'DH_USER' and 'DH_KEY'"
+        display "2) create file ~/.Dreamyrc with user on first line and key on second\n\n"
+        exit 1
+      end
+      @credentials
+    end
+    
+
+  end
+
+end

data/lib/dreamy/commands/dns.rb

@@ -0,0 +1,26 @@
+module Dreamy::Command
+  class Dns < Base
+    
+    def list
+      dns = @account.dns
+      
+      if args.length > 0
+        filter = args.shift.downcase
+        dns = dns.select { |d| d.zone.match(filter) }
+      end
+      
+      if dns.empty?
+        display "No DNS records for this account or requested zone not found"
+      else
+        dns_table = table do |t|
+          t.headings = 'Record', 'Type', 'Value'
+          dns.each { |d| t << [d.record,d.type,d.value] if d.type != "TXT" }
+        end
+        display "NOTE: TXT records not displayed (too long)"
+        display dns_table
+      end
+    end
+    alias :index :list
+    
+  end
+end

data/lib/dreamy/commands/domains.rb

@@ -0,0 +1,42 @@
+require 'ping'
+
+module Dreamy::Command
+  class Domains < Base
+    
+    def index
+      domains = @account.domains
+      if domains.empty?
+        display "No domains on this account"
+      else
+        domain_table = table do |t|
+          t.headings = 'Domain Name', 'Server', 'Type', 'User', 'WWW or Not'
+          domains.each { |d| t << [d.domain,d.short_home,d.hosting_type,d.user,d.www_or_not]}
+        end
+        display domain_table
+      end
+    end
+    
+    def status
+      domains = @account.domains
+      domains.each do |d|
+        if host_available?(d.domain)
+          display "#{d.domain} is up"
+        else
+          display "#{d.domain} is down!"
+          if host_available?(d.home)
+            display "  But its host server (#{d.home}) is up"
+          else
+            display "  And its host server (#{d.home}) is down"
+          end
+        end
+      end
+    end
+    
+    protected
+    
+    def host_available?(host)
+      Ping.pingecho host
+    end
+    
+  end
+end

data/lib/dreamy/commands/help.rb

@@ -0,0 +1,25 @@
+module Dreamy::Command
+	class Help < Base
+		def index
+			display usage
+		end
+
+		def usage
+			usage = <<EOTXT
+
+=== Commands
+
+ help                         # show this usage
+
+ domains                      # list domains
+ domains:status               # check availability of all domains
+ 
+ dns                          # list your DNS records
+ dns <name>                   # list DNS records for <ame>
+ 
+ users                        # list user accounts
+
+EOTXT
+		end
+	end
+end

data/lib/dreamy/commands/users.rb

@@ -0,0 +1,18 @@
+module Dreamy::Command
+  class Users < Base
+    
+    def index
+      users = @account.users
+      if users.empty?
+        display "No users on this account"
+      else
+        user_table = table do |t|
+          t.headings = 'Name', 'Account Type', 'Server', 'Disk used (MB)', 'Quota (MB)'
+          users.each { |u| t << [u.gecos, u.type, u.home, u.disk_used_mb, u.quota_mb]  }
+        end
+        display user_table
+      end
+    end
+    
+  end
+end

data/lib/dreamy/control.rb

@@ -0,0 +1,79 @@
+module Dreamy
+  class Control
+
+    @@host = "api.dreamhost.com"
+
+    def initialize(username, key)
+      @username = username
+      @key      = key
+    end
+    
+    # returns an array of domain objects
+    def domains
+      doc = request("domain-list_domains")
+      (doc/:data).inject([]) { |domains, domain| domains << Domain.new_from_xml(domain); domains }
+    end
+    
+    # returns an array of user objects
+    def users(passwords=false)
+      if passwords
+        doc = request("user-list_users")
+      else
+        doc = request("user-list_users_no_pw")
+      end
+      
+      (doc/:data).inject([]) { |users, user| users << User.new_from_xml(user); users }
+    end
+    
+    # returns an array of dns objects
+    def dns
+      doc = request("dns-list_records")
+      (doc/:data).inject([]) { |records, dns| records << Dns.new_from_xml(dns); records }
+    end
+    
+    def request(cmd,values={})
+      handle_response!(response(cmd,values))
+    end
+    
+     private
+
+    def response(cmd,values={})
+      params = [
+        "username=#{@username}",
+        "key=#{@key}",
+        "cmd=#{cmd}",
+        "format=xml",
+        "unique_id=#{UUID.new.generate}",
+      ]
+      
+      path = "/?#{params.join("&")}"
+      http = Net::HTTP.new(@@host, 443)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      begin
+        response = http.get(path)
+      rescue => error
+        raise CantConnect, error.message
+      end
+    end
+    
+    def handle_response!(response)
+      if %w[200 304].include?(response.code)
+        response = parse(response.body)
+      elsif response.code == '503'
+        raise Unavailable, response.message
+      elsif response.code == '401'
+        raise CantConnect, 'Authentication failed. Check your username and password'
+      else
+        raise CantConnect, "Dreamy is returning a #{response.code}: #{response.message}"
+      end
+    end
+    
+    # Converts a string response into an Hpricot xml element.
+    def parse(response)
+      Hpricot.XML(response || '')
+    end
+
+  end
+end

data/lib/dreamy/dns.rb

@@ -0,0 +1,20 @@
+module Dreamy
+  class Dns
+    include EasyClassMaker
+
+    attributes  :account_id, :comment, :editable, :record, :type, :value, :zone
+
+    def self.new_from_xml(xml)
+      d = new
+      d.account_id  = (xml).at('account_id').innerHTML
+      d.comment     = (xml).at('comment').innerHTML
+      # TODO - enable this if DH guys change the API as requested
+      # d.editable    = (xml).at('editable').innerHTML
+      d.record      = (xml).at('record').innerHTML
+      d.type        = (xml).at('type').innerHTML
+      d.value       = (xml).at('value').innerHTML
+      d.zone        = (xml).at('zone').innerHTML
+      d
+    end
+  end
+end

data/lib/dreamy/domain.rb

@@ -0,0 +1,33 @@
+module Dreamy
+  class Domain
+    include EasyClassMaker
+
+    attributes  :account_id, :domain, :fastcgi, :home, :hosting_type, :outside_url, :passenger,
+                :path, :php, :php_fcgid, :security, :type, :unique_ip, :user, :www_or_not, :xcache
+
+    def self.new_from_xml(xml)
+      d = new
+      d.account_id    = (xml).at('account_id').innerHTML
+      d.domain        = (xml).at('domain').innerHTML
+      d.fastcgi       = (xml).at('fastcgi').innerHTML
+      d.home          = (xml).at('home').innerHTML
+      d.hosting_type  = (xml).at('hosting_type').innerHTML
+      d.outside_url   = (xml).at('outside_url').innerHTML
+      d.passenger     = (xml).at('passenger').innerHTML
+      d.path          = (xml).at('path').innerHTML
+      d.php           = (xml).at('php').innerHTML
+      d.php_fcgid     = (xml).at('php_fcgid').innerHTML
+      d.security      = (xml).at('security').innerHTML
+      d.type          = (xml).at('type').innerHTML
+      d.unique_ip     = (xml).at('unique_ip').innerHTML
+      d.user          = (xml).at('user').innerHTML
+      d.www_or_not    = (xml).at('www_or_not').innerHTML
+      d.xcache        = (xml).at('xcache').innerHTML
+      d
+    end
+    
+    def short_home
+      home.gsub(".Dreamy.com","")
+    end
+  end
+end

data/lib/dreamy/easy_class_maker.rb

@@ -0,0 +1,43 @@
+# This is pretty much just a macro for creating a class that allows
+# using a block to initialize stuff and to define getters and setters
+# really quickly.
+module Dreamy
+  module EasyClassMaker
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      # creates the attributes class variable and creates each attribute's accessor methods
+      def attributes(*attrs)
+        @@attributes = attrs
+        @@attributes.each { |a| attr_accessor a }
+      end
+      
+      # read method for attributes class variable
+      def self.attributes; @@attributes end
+    end
+    
+    # allows for any class that includes this to use a block to initialize
+    # variables instead of assigning each one seperately
+    # 
+    # Example: 
+    # 
+    # instead of...
+    # 
+    # s = Status.new
+    # s.foo = 'thing'
+    # s.bar = 'another thing'
+    #
+    # you can ...
+    # 
+    # Status.new do |s|
+    #   s.foo = 'thing'
+    #   s.bar = 'another thing'
+    # end
+    def initialize
+      yield self if block_given?
+    end
+  end
+end

data/lib/dreamy/user.rb

@@ -0,0 +1,21 @@
+module Dreamy
+  class User
+    include EasyClassMaker
+
+    attributes  :account_id, :disk_used_mb, :gecos, :home, :password, :quota_mb, :shell, :type, :username
+
+    def self.new_from_xml(xml)
+      u = new
+      u.account_id    = (xml).at('account_id').innerHTML
+      u.disk_used_mb  = (xml).at('disk_used_mb').innerHTML
+      u.gecos         = (xml).at('gecos').innerHTML
+      u.home          = (xml).at('home').innerHTML
+      u.password      = (xml).at('password').innerHTML
+      u.quota_mb      = (xml).at('quota_mb').innerHTML
+      u.shell         = (xml).at('shell').innerHTML
+      u.type          = (xml).at('type').innerHTML
+      u.username      = (xml).at('username').innerHTML
+      u
+    end
+  end
+end

data/test/control_test.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + "/test_helper.rb"
+
+class DreamyControlTest < Test::Unit::TestCase
+  
+  @@base = Dreamy::Control.new(CREDS["user"],CREDS["key"])
+  
+  context "Initialization" do
+
+    should "require email and API key" do
+      assert_raise(ArgumentError) { Dreamy::Control.new }
+    end
+    
+  end
+  
+  context "Domains" do
+
+    should "return array of domain objects" do
+      assert_kind_of Array, @@base.domains
+      assert_kind_of Dreamy::Domain, @@base.domains.first
+    end
+    
+  end
+  
+  context "Users" do
+
+    should "return array of user objects" do
+      assert_kind_of Array, @@base.users
+      assert_kind_of Dreamy::User, @@base.users.first
+    end
+    
+    should "not include user passwords by default" do
+      assert_equal "********", @@base.users.first.password
+    end
+  end
+  
+  context "DNS" do
+
+    should "return array of DNS records" do
+      assert_kind_of Array, @@base.dns
+      assert_kind_of Dreamy::Dns, @@base.dns.first
+    end
+  end
+  
+  
+end

data/test/dns_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + "/test_helper.rb"
+
+class DreamyDnsTest < Test::Unit::TestCase
+
+  context "Creation" do
+    setup do
+      @xml = <<EOF
+<data>
+    <account_id>8675309</account_id>
+    <comment></comment>
+    <editable?>0</editable?>
+    <record>anessalee.net</record>
+    <type>A</type>
+    <value>202.22.191.4</value>
+    <zone>anessalee.net</zone>
+  </data>
+EOF
+    end
+
+    should "create a new DNS entry from xml" do
+      d = Dreamy::Dns.new_from_xml(Hpricot.XML(@xml))
+      assert_equal "8675309", d.account_id
+      assert_equal "", d.comment
+      # assert_equal "0", d.editable
+      assert_equal "anessalee.net", d.record
+      assert_equal "A", d.type
+      assert_equal "202.22.191.4", d.value
+      assert_equal "anessalee.net", d.zone
+    end
+  end
+  
+end

data/test/domain_test.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + "/test_helper.rb"
+
+class DreamyDomainTest < Test::Unit::TestCase
+
+  context "Creation" do
+    setup do
+      @xml = <<EOF
+<data>
+  <account_id>8675309</account_id>
+  <domain>anessalee.net</domain>
+  <fastcgi>0</fastcgi>
+  <home>juniormint.Dreamy.com</home>
+  <hosting_type>full</hosting_type>
+  <outside_url></outside_url>
+  <passenger>0</passenger>
+  <path>anessalee.net</path>
+  <php>pcgi5</php>
+  <php_fcgid>0</php_fcgid>
+  <security>0</security>
+  <type>http</type>
+  <unique_ip></unique_ip>
+  <user>sant0sk1</user>
+  <www_or_not>both_work</www_or_not>
+  <xcache>0</xcache>
+</data>
+EOF
+    @d = Dreamy::Domain.new_from_xml(Hpricot.XML(@xml))
+    end
+
+    should "assign valid domain from xml" do
+      assert_equal "8675309", @d.account_id
+      assert_equal "anessalee.net", @d.domain
+      assert_equal "0", @d.fastcgi
+      assert_equal "juniormint.Dreamy.com", @d.home
+      assert_equal "full", @d.hosting_type
+      assert_equal "", @d.outside_url
+      assert_equal "0", @d.passenger
+      assert_equal "anessalee.net", @d.path
+      assert_equal "pcgi5", @d.php
+      assert_equal "0", @d.php_fcgid
+      assert_equal "0", @d.security
+      assert_equal "http", @d.type
+      assert_equal "", @d.unique_ip
+      assert_equal "sant0sk1", @d.user
+      assert_equal "both_work", @d.www_or_not
+      assert_equal "0", @d.xcache
+    end
+    
+    should "return shortened server name if requested" do
+      assert_equal "juniormint", @d.short_home
+    end
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+
+dir = File.dirname(__FILE__)
+
+$:.unshift(File.join(dir, '/../lib/'))
+require dir + '/../lib/dreamy'
+
+CREDS = YAML::load(File.open("#{dir}/credentials.yml"))

data/test/user_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/test_helper.rb"
+
+class DreamyUserTest < Test::Unit::TestCase
+
+  context "Creation" do
+    setup do
+      @xml = <<EOF
+<data>
+    <account_id>8675309</account_id>
+    <disk_used_mb>0</disk_used_mb>
+    <gecos>Joe Schmoe</gecos>
+    <home>spork.Dreamy.com</home>
+    <password>YahRight!</password>
+    <quota_mb>50</quota_mb>
+    <shell>/bin/bash</shell>
+    <type>mail</type>
+    <username>joe@schmoe.com</username>
+  </data>
+EOF
+    end
+
+    should "create a new user from xml" do
+      u = Dreamy::User.new_from_xml(Hpricot.XML(@xml))
+      assert_equal "8675309", u.account_id
+      assert_equal "0", u.disk_used_mb
+      assert_equal "Joe Schmoe", u.gecos
+      assert_equal "spork.Dreamy.com", u.home
+      assert_equal "YahRight!", u.password
+      assert_equal "50", u.quota_mb
+      assert_equal "/bin/bash", u.shell
+      assert_equal "mail", u.type
+      assert_equal "joe@schmoe.com", u.username
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: sant0sk1-dreamy
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Jerod Santo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-18 00:00:00 -07:00
+default_executable: dh
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: visionmedia-terminal-table
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.5
+    version: 
+description: 
+email: jerod.santo@gmail.com
+executables: 
+- dh
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- Rakefile
+- VERSION.yml
+- bin/dh
+- lib/dreamy.rb
+- lib/dreamy/command.rb
+- lib/dreamy/commands/base.rb
+- lib/dreamy/commands/dns.rb
+- lib/dreamy/commands/domains.rb
+- lib/dreamy/commands/help.rb
+- lib/dreamy/commands/users.rb
+- lib/dreamy/control.rb
+- lib/dreamy/dns.rb
+- lib/dreamy/domain.rb
+- lib/dreamy/easy_class_maker.rb
+- lib/dreamy/user.rb
+- test/control_test.rb
+- test/dns_test.rb
+- test/domain_test.rb
+- test/test_helper.rb
+- test/user_test.rb
+has_rdoc: true
+homepage: http://github.com/sant0sk1/dreamy
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Ruby library and command line tool for accessing DreamHost's API
+test_files: 
+- test/control_test.rb
+- test/dns_test.rb
+- test/domain_test.rb
+- test/test_helper.rb
+- test/user_test.rb