rimu 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a41e8677143f391e930053daa0a4b716ec789150
-  data.tar.gz: 1c359d88df138a4423c619a7c5f84af161d6c958
+  metadata.gz: 9d83c7258f16b129d5d5c0b40558a1b204ea69f3
+  data.tar.gz: 8a52d90147459954396a2af7a2e4d78900036420
 SHA512:
-  metadata.gz: d2918c424fc5d58a297eb1d3282316287601b95f1ce101578c84a7ece6315233a7b4b4f17b563308010cf097497f616de5574644f22b13cc28c8cdcac37650a5
-  data.tar.gz: 1e0221a0bc3bdb6e50739c29a31938720f06abd9a356c929542cbec8c76c86f71a6171d6a79326e5c1ef352b5fc4671143a3eebef029170ccd30868f2001c112
+  metadata.gz: 5959c9a9c13b598c6801217f400eb291ae5a908ffa4e37116fc246d82df415034f3993defab16a494ecff3477bf1579c672508f533ac38a16af763e33fa97353
+  data.tar.gz: 10c18c690337109a0c637dbaa703aa6ca60b53a4dac7d05b260acdac6178da3dc8fd6bb45b998bbc7eb791f148a16654cca7d869e8917b20ace3df41d878ec7a

data/lib/rimu/orders.rb

@@ -1,19 +1,21 @@
 require 'cgi'
 
-class Rimu::Orders < Rimu
-    def orders(params={})
-        raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
-        default_params = {
-            :include_inactive => 'N',
-            :server_type => 'VPS',
-        }
-        filters = prep_data(default_params, params)
-        path = "/r/orders;" + filters.collect {|k,v| "#{k}=#{CGI::escape(v.to_s)}"}.join(';')
-        send_request(path, "about_orders")
-    end
+module Rimu
+  class RimuAPI::Orders < Rimu::RimuAPI
+      def orders(params={})
+          raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
+          default_params = {
+              :include_inactive => 'N',
+              :server_type => 'VPS',
+          }
+          filters = prep_data(default_params, params)
+          path = "/r/orders;" + filters.collect {|k,v| "#{k}=#{CGI::escape(v.to_s)}"}.join(';')
+          send_request(path, "about_orders")
+      end
 
-    def order(oid)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        send_request("/r/orders/order-#{oid}-dn", "about_order")
-    end
+      def order(oid)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          send_request("/r/orders/order-#{oid}-dn", "about_order")
+      end
+  end
 end

data/lib/rimu/servers.rb

@@ -1,122 +1,126 @@
-class Rimu::Servers < Rimu
-    def default_vps_params
-        @default_vps_params = {
-            :billing_oid => nil,
-            :dc_location => nil,
-            :file_injection_data => nil,
-            :host_server_oid => nil,
-            :instantiation_options => {
-                :domain_name => nil,
-                :password => nil,
-                :distro => nil,
-                :cloud_config_data => nil,
-                :control_panel => nil,
-            },
-            :instantiation_via_clone_options => {
-                :domain_name => nil,
-                :vps_order_oid_to_clone => nil,
-            },
-            :ip_request => {
-                :extra_ip_reason => nil,
-                :num_ips => nil,
-                :requested_ips => nil,
-            },
-            :is_just_minimal_init => nil,
-            :meta_data => nil,
-            :pricing_plan_code => nil,
-            :user_oid => nil,
-            :vps_parameters => {
-                :disk_space_mb => nil,
-                :memory_mb => nil,
-                :disk_space_2_mb => nil,
-            },
-            :vps_type => nil,
-        }
-    end
+module Rimu
+  class RimuAPI::Servers < Rimu::RimuAPI
+      def default_vps_params
+          @default_vps_params = {
+              :billing_oid => nil,
+              :dc_location => nil,
+              :file_injection_data => nil,
+              :host_server_oid => nil,
+              :instantiation_options => {
+                  :domain_name => nil,
+                  :password => nil,
+                  :distro => nil,
+                  :cloud_config_data => nil,
+                  :control_panel => nil,
+              },
+              :instantiation_via_clone_options => {
+                  :domain_name => nil,
+                  :vps_order_oid_to_clone => nil,
+              },
+              :ip_request => {
+                  :extra_ip_reason => nil,
+                  :num_ips => nil,
+                  :requested_ips => nil,
+              },
+              :is_just_minimal_init => nil,
+              :meta_data => nil,
+              :pricing_plan_code => nil,
+              :user_oid => nil,
+              :vps_parameters => {
+                  :disk_space_mb => nil,
+                  :memory_mb => nil,
+                  :disk_space_2_mb => nil,
+              },
+              :vps_type => nil,
+          }
+      end
 
-    def create(params)
-        raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
-        raise ArgumentError, "params should contain atleast instantiation_options or instantiation_via_clone_options" \
-        unless params.has_key?(:instantiation_options) || params.has_key?(:instantiation_via_clone_options)
-        data = {:new_order_request => prep_data(default_vps_params, params)}
-        send_request("/r/orders/new-vps", "about_order", "POST", data)
-    end
+      def create(params)
+          raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
+          raise ArgumentError, "params should contain atleast instantiation_options or instantiation_via_clone_options" \
+          unless params.has_key?(:instantiation_options) || params.has_key?(:instantiation_via_clone_options)
+          data = {:new_order_request => prep_data(default_vps_params, params)}
+          send_request("/r/orders/new-vps", "about_order", "POST", data)
+      end
 
-    def reinstall(oid, params={})
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
-        data = {:reinstall_request => prep_data(default_vps_params, params)}
-        send_request("/r/orders/order-#{oid}-dn/vps/reinstall", "running_vps_info", "PUT", data)
-    end
+      def reinstall(oid, params={})
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
+          data = {:reinstall_request => prep_data(default_vps_params, params)}
+          send_request("/r/orders/order-#{oid}-dn/vps/reinstall", "running_vps_info", "PUT", data)
+      end
 
-    def status(oid)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        send_request("/r/orders/order-#{oid}-dn/vps", "running_vps_info")
-    end
+      def status(oid)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          send_request("/r/orders/order-#{oid}-dn/vps", "running_vps_info")
+      end
 
-    def info(oid)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        send_request("/r/orders/order-#{oid}-dn", "about_order")
-    end
+      def info(oid)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          send_request("/r/orders/order-#{oid}-dn", "about_order")
+      end
 
-    def cancel(oid)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        send_request("/r/orders/order-#{oid}-dn/vps", "cancel_messages", "DELETE")
-    end
+      def cancel(oid)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          send_request("/r/orders/order-#{oid}-dn/vps", "cancel_messages", "DELETE")
+      end
 
-    def move(oid, params)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
-        default_params = {
-            :update_dns=>false,
-            :move_reason=>'',
-            :pricing_change_option=>'CHOOSE_BEST_OPTION',
-            :selected_host_server_oid=>nil
-        }
-        data = {:vps_move_request => prep_data(default_params, params)}
-        send_request("/r/orders/order-#{oid}-dn/vps/host-server", "about_order", "PUT", data)
-    end
+      def move(oid, params={})
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
+          default_params = {
+              :update_dns=>false,
+              :move_reason=>'',
+              :pricing_change_option=>'CHOOSE_BEST_OPTION',
+              :selected_host_server_oid=>nil,
+          }
+          data = {:vps_move_request => prep_data(default_params, params)}
+          send_request("/r/orders/order-#{oid}-dn/vps/host-server", "about_order", "PUT", data)
+      end
 
-    def resize(oid, params)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
-        default_params = {
-            :disk_space_2_mb => nil,
-            :disk_space_mb => nil,
-            :memory_mb => nil,
-        }
-        data = {:vps_resize_request => prep_data(default_params, params)}
-        send_request("/r/orders/order-#{oid}-dn/vps/parameters", "resource_change_result", "PUT", data)
-    end
+      def resize(oid, params)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          raise ArgumentError, "params should be a hash" unless params.is_a?(Hash)
+          default_params = {
+              :disk_space_2_mb => nil,
+              :disk_space_mb => nil,
+              :memory_mb => nil,
+          }
+          clean_params = prep_data(default_params, params)
+          raise ArgumentError, "atleast one parameter is required" if clean_params.empty?
+          data = {:vps_resize_request => clean_params}
+          send_request("/r/orders/order-#{oid}-dn/vps/parameters", "resource_change_result", "PUT", data)
+      end
 
-    def change_state(oid, new_state)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        params = {:running_state_change_request=>{:running_state=>new_state}}
-        send_request("/r/orders/order-#{oid}-dn/vps/running-state", "running_vps_info", "PUT", params)
-    end
+      def change_state(oid, new_state)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          params = {:running_state_change_request=>{:running_state=>new_state}}
+          send_request("/r/orders/order-#{oid}-dn/vps/running-state", "running_vps_info", "PUT", params)
+      end
 
-    def reboot(oid)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        change_state(oid, "RESTARTING")
-    end
+      def reboot(oid)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          change_state(oid, "RESTARTING")
+      end
 
-    def shutdown(oid)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        change_state(oid, "NOTRUNNING")
-    end
+      def shutdown(oid)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          change_state(oid, "NOTRUNNING")
+      end
 
-    def start(oid)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        change_state(oid, "RUNNING")
-    end
+      def start(oid)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          change_state(oid, "RUNNING")
+      end
 
-    def power_cycle(oid)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        change_state(oid, "POWERCYCLING")
-    end
+      def power_cycle(oid)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          change_state(oid, "POWERCYCLING")
+      end
 
-    def data_transfer(oid)
-        raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
-        send_request("/r/orders/order-#{oid}-dn/vps/data-transfer-usage", "data_transfer_usage_info")
-    end
+      def data_transfer(oid)
+          raise ArgumentError, "oid should be an Integer" unless oid.is_a?(Integer)
+          send_request("/r/orders/order-#{oid}-dn/vps/data-transfer-usage", "data_transfer_usage_info")
+      end
+  end
 end

data/lib/rimu/version.rb

@@ -0,0 +1,6 @@
+module Rimu
+  module Version
+    VERSION = '0.0.5'
+    VERSION_PATTERN = /^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/
+  end
+end

data/lib/rimu.rb

@@ -2,155 +2,157 @@ require 'json'
 require 'ostruct'
 require 'httparty'
 
-class Rimu
-    attr_accessor :logger
-
-    def initialize(args)
-        @api_url = args[:api_url] if args[:api_url]
-        @logger = args[:logger]
-        if args.include?(:api_key)
-            @api_key = args[:api_key]
-        else
-            raise ArgumentError, "The :api_key is required."
-        end
-        @read_timeout = args[:read_timeout] if args[:read_timeout]
-        raise ArgumentError, "The :read_timeout must be an Integer." if ! @read_timeout.nil? && ! @read_timeout.is_a?(Integer)
-    end
-
-    def api_url
-        @api_url || "https://api.rimuhosting.com"
-    end
-
-    def api_key
-        @api_key
-    end
-
-    def read_timeout
-        @read_timeout || 3600
-    end
-
-    def set_headers
-        {
-            'Content-Type' =>'application/json',
-            'Accept' =>'application/json',
-            'User-Agent' => 'RimuAPI-Ruby',
-            'Authorization' => "rimuhosting apikey=#{api_key}",
-        }
-    end
-
-    def error?(response)
-        if response.nil?
-            return true
-        else
-            if response.is_a?(Hash) && ! response.empty?
-                ! response.empty? and response[response.keys[0]] and \
-                response[response.keys[0]].has_key?("response_type") and \
-                response[response.keys[0]]["response_type"] == "ERROR"
+module Rimu
+  class RimuAPI
+      attr_accessor :logger
+
+      def initialize(args)
+          @api_url = args[:api_url] if args[:api_url]
+          @logger = args[:logger]
+          if args.include?(:api_key)
+              @api_key = args[:api_key]
+          else
+              raise ArgumentError, "The :api_key is required."
+          end
+          @read_timeout = args[:read_timeout] if args[:read_timeout]
+          raise ArgumentError, "The :read_timeout must be an Integer." if ! @read_timeout.nil? && ! @read_timeout.is_a?(Integer)
+      end
+
+      def api_url
+          @api_url || "https://api.rimuhosting.com"
+      end
+
+      def api_key
+          @api_key
+      end
+
+      def read_timeout
+          @read_timeout || 3600
+      end
+
+      def set_headers
+          {
+              'Content-Type' =>'application/json',
+              'Accept' =>'application/json',
+              'User-Agent' => 'RimuAPI-Ruby',
+              'Authorization' => "rimuhosting apikey=#{api_key}",
+          }
+      end
+
+      def error?(response)
+          if response.nil?
+              return true
+          else
+              if response.is_a?(Hash) && ! response.empty?
+                  ! response.empty? and response[response.keys[0]] and \
+                  response[response.keys[0]].has_key?("response_type") and \
+                  response[response.keys[0]]["response_type"] == "ERROR"
+              else
+                  return true
+              end
+          end
+      end
+
+      def error_message(response)
+          if response.nil? || ! response.is_a?(Hash) || (response.is_a?(Hash) && response.empty?)
+            if response.empty?
+              "  - Error: Response was empty"
             else
-                return true
+              "  - Error: Unknown error occured"
             end
-        end
-    end
+          else
+              if response[response.keys[0]].has_key?("human_readable_message")
+                  error = response[response.keys[0]]["human_readable_message"]
+                  "  - Error: #{error}"
+              else
+                  "  - Error: Unknown error occured"
+              end
+          end
+      end
 
-    def error_message(response)
-        if response.nil? || ! response.is_a?(Hash) || (response.is_a?(Hash) && response.empty?)
-          if response.empty?
-            "  - Error: Response was empty"
+      def format_response(response, field)
+          result = response[response.keys[0]]
+          if result.is_a?(Hash) and result.has_key?(field)
+              result = result[field]
+          end
+          return result.collect {|item| convert_item(item) } if result.class == Array
+          return result unless result.respond_to?(:keys)
+          convert_item(result)
+      end
+
+      def convert_item(response)
+          response.keys.each do |key|
+              response[key.downcase] = response[key]
+              response.delete(key) if key != key.downcase
+          end
+          OpenStruct.new(response)
+      end
+
+      def send_request(path, field, method="GET", data=nil)
+          logger.info "#{method} #{api_url}#{path} body:#{data.inspect}" if logger
+          if data.nil?
+            options = {headers: set_headers}
           else
-            "  - Error: Unknown error occured"
+            options = {headers: set_headers, body: data.to_json, read_timeout: read_timeout}
           end
-        else
-            if response[response.keys[0]].has_key?("human_readable_message")
-                error = response[response.keys[0]]["human_readable_message"]
-                "  - Error: #{error}"
-            else
-                "  - Error: Unknown error occured"
-            end
-        end
-    end
-
-    def format_response(response, field)
-        result = response[response.keys[0]]
-        if result.is_a?(Hash) and result.has_key?(field)
-            result = result[field]
-        end
-        return result.collect {|item| convert_item(item) } if result.class == Array
-        return result unless result.respond_to?(:keys)
-        convert_item(result)
-    end
-
-    def convert_item(response)
-        response.keys.each do |key|
-            response[key.downcase] = response[key]
-            response.delete(key) if key != key.downcase
-        end
-        OpenStruct.new(response)
-    end
-
-    def send_request(path, field, method="GET", data=nil)
-        logger.info "#{method} #{api_url}#{path} body:#{data.inspect}" if logger
-        if data
-          options = {headers: set_headers, body: data.to_json, read_timeout: read_timeout} if data
-        else
-          options = {headers: set_headers}
-        end
-        begin
-          response = HTTParty.send(method.downcase.to_sym, path, options).parsed_response
-        rescue StandardError => e
-          raise RimuRequestError, "Errors completing request #{method} #{api_url}#{path} with data [#{data.inspect}]:\n#{e}"
-        end
-        raise RimuResponseError, "Errors completing request #{method} #{api_url}#{path} with data [#{data.inspect}]:\n#{error_message(response)}" if error?(response)
-        logger.info "Response: => #{response}" if logger
-        format_response(response, field)
-    end
-
-    def distributions
-        send_request("/r/distributions", "distro_infos")
-    end
-
-    def billing_methods
-        send_request("/r/billing-methods", "billing_methods")
-    end
-
-    def prep_data(default_params, params)
-        params.keep_if {|k,_| default_params.keys.include? k }
-        new_params = default_params.merge(params)
-        new_params.each_pair do |key, val|
-            if val.is_a?(Hash)
-                val.keep_if {|_,v| v != nil }
-                val.keep_if {|k,_| default_params[key].keys.include? k }
-            end
-        end
-        new_params.keep_if {|_,v| (v.is_a?(Hash) && ! v.empty?) || (! v.is_a?(Hash) && v != nil) }
-        return new_params
-    end
-
-    def self.has_namespace(*namespaces)
-        namespaces.each do |namespace|
-            define_method(namespace.to_sym) do ||
-                lookup = instance_variable_get("@#{namespace}")
-                return lookup if lookup
-                subclass = self.class.const_get(namespace.to_s.capitalize).new(
-                    :api_key => api_key,
-                    :api_url => api_url,
-                    :logger => logger,
-                    :read_timeout => read_timeout,
-                )
-                instance_variable_set("@#{namespace}", subclass)
-                subclass
-            end
-        end
-    end
+          begin
+            response = HTTParty.send(method.downcase.to_sym, path, options).parsed_response
+          rescue StandardError => e
+            raise RimuRequestError, "Errors completing request #{method} #{api_url}#{path} with data [#{data.inspect}]:\n#{e}"
+          end
+          raise RimuResponseError, "Errors completing request #{method} #{api_url}#{path} with data [#{data.inspect}]:\n#{error_message(response)}" if error?(response)
+          logger.info "Response: => #{response}" if logger
+          format_response(response, field)
+      end
+
+      def distributions
+          send_request("/r/distributions", "distro_infos")
+      end
+
+      def billing_methods
+          send_request("/r/billing-methods", "billing_methods")
+      end
+
+      def prep_data(default_params, params)
+          params.keep_if {|k,_| default_params.keys.include? k }
+          new_params = default_params.merge(params)
+          new_params.each_pair do |key, val|
+              if val.is_a?(Hash)
+                  val.keep_if {|_,v| v != nil }
+                  val.keep_if {|k,_| default_params[key].keys.include? k }
+              end
+          end
+          new_params.keep_if {|_,v| (v.is_a?(Hash) && ! v.empty?) || (! v.is_a?(Hash) && v != nil) }
+          return new_params
+      end
+
+      def self.has_namespace(*namespaces)
+          namespaces.each do |namespace|
+              define_method(namespace.to_sym) do ||
+                  lookup = instance_variable_get("@#{namespace}")
+                  return lookup if lookup
+                  subclass = self.class.const_get(namespace.to_s.capitalize).new(
+                      :api_key => api_key,
+                      :api_url => api_url,
+                      :logger => logger,
+                      :read_timeout => read_timeout,
+                  )
+                  instance_variable_set("@#{namespace}", subclass)
+                  subclass
+              end
+          end
+      end
 
-    has_namespace :orders, :servers
+      has_namespace :orders, :servers
 
-    class RimuArgumentError < ArgumentError
-    end
+      class RimuArgumentError < ArgumentError
+      end
 
-    class RimuRequestError < ArgumentError
-    end
+      class RimuRequestError < StandardError
+      end
 
-    class RimuResponseError < ArgumentError
-    end
+      class RimuResponseError < StandardError
+      end
+  end
+  Dir[File.expand_path(File.dirname(__FILE__) + '/rimu/*.rb')].each {|f| require f }
 end
-Dir[File.expand_path(File.dirname(__FILE__) + '/rimu/*.rb')].each {|f| require f }

data/rimu.gemspec

@@ -1,8 +1,11 @@
 # coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rimu/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "rimu"
-  spec.version       = "0.0.4"
+  spec.version       = Rimu::Version::VERSION
   spec.authors       = ["Andrew Colin Kissa"]
   spec.email         = ["andrew@topdog.za.net"]
   spec.license       = "MPL-2.0"

metadata

@@ -1,125 +1,125 @@
 --- !ruby/object:Gem::Specification
 name: rimu
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Andrew Colin Kissa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-22 00:00:00.000000000 Z
+date: 2015-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-expectations
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 description: This is a Ruby wrapper around Rimuhosting's REST API
@@ -130,11 +130,11 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
-- .codeclimate.yml
-- .gitignore
-- .rspec
-- .rubocop.yml
-- .travis.yml
+- ".codeclimate.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -142,6 +142,7 @@ files:
 - lib/rimu.rb
 - lib/rimu/orders.rb
 - lib/rimu/servers.rb
+- lib/rimu/version.rb
 - rimu.gemspec
 homepage: https://github.com/akissa/rimu
 licenses:
@@ -153,17 +154,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for the Rimuhosting REST API