hdcore 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hdcore.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ethan Pemble
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Hdcore
+
+A basic wrapper for HostDime's customer portal 'Core' API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hdcore'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hdcore
+
+## Usage
+
+https://api.hostdime.com/
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/hdcore.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hdcore/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hdcore"
+  spec.version       = Hdcore::VERSION
+  spec.authors       = ["Ethan Pemble"]
+  spec.email         = ["ethan.p@hostdime.com"]
+  spec.description   = "A basic wrapper for HostDime's customer portal 'Core' API"
+  spec.summary       = ""
+  spec.homepage      = "https://github.com/hostdime/hdcore"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.13"
+  spec.add_dependency "httparty", "~> 0.11"
+end

data/lib/hdcore/hdcore.rb

@@ -0,0 +1,60 @@
+#
+module Hdcore
+  @log = Logger.new(STDOUT)
+
+  # Default configuration values
+  @config = {
+              api_endpoint: 'core.hostdime.com/api/v1',
+              public_key:   nil,
+              private_key:  nil
+            }
+  @valid_config_keys = @config.keys
+
+  class << self
+    # Configure HDCore with an options hash.
+    # @param [Hash] opts Configuration options hash
+    # @option opts [String] :api_endpoint ('core.hostdime.com/api/v1') The HDCore API endpoint URI
+    # @option opts [String] :public_key Your HDCore public key
+    # @option opts [String] :private_key Your HDCore private key
+    def configure opts = {}
+      opts.each do |key, val|
+        config[key.to_sym] = val if @valid_config_keys.include? key.to_sym
+      end
+    end
+
+    # Configure HDCore with an external yaml config file.
+    # @param [String] path_to_yaml_file Absolute path to yaml config file
+    def configure_with path_to_yaml_file
+      begin
+        config = YAML::load(IO.read(path_to_yaml_file))
+      rescue Errno::ENOENT
+        log.warn "YAML config file not found: using defaults instead"; return
+      rescue Psych::SyntaxError
+        log.warn "YAML config file has invalid syntax: using defaults instead"; return
+      end
+
+      configure(config)
+    end
+
+    # Current configuration hash
+    def config
+      @config
+    end
+
+    # For logging purposes
+    def log
+      @log
+    end
+
+    # @return [Bool] True if there are configuration keys that have no assigned value.
+    def missing_config_values?
+      config.values.include? nil
+    end
+
+    # @return [Array] Configuration keys that have no assigned value.
+    def missing_config_values
+      config.select{|k,v| v.nil?}.keys
+    end
+  end
+
+end

data/lib/hdcore/request.rb

@@ -0,0 +1,75 @@
+#
+module Hdcore
+  class Request
+    include HTTParty
+
+    class << self
+
+      # Initializes the request: throws exception if there are configs missing (requires public and private keys)
+      # @param [String] action The full API action
+      def init
+        # Make sure required config values are set
+        if Hdcore.missing_config_values?
+          msg = "Hdcore is not yet properly configured: Missing #{Hdcore.missing_config_values}"
+
+          Hdcore.log.error(msg)
+          raise Exception, msg, caller
+        end
+
+        # set base uri for HTTParty request
+        base_uri Hdcore.config[:api_endpoint]
+      end
+
+      # @return [String] public key established in configuration
+      def public_key
+        Hdcore.config[:public_key]
+      end
+
+      # @return [String] private key established in configuration
+      def private_key
+        Hdcore.config[:private_key]
+      end
+
+      # @param [String] action The full API action
+      # @param [Hash] params The given action parameters
+      # @return [HTTParty::Response]
+      def send(action, params = {})
+        init()
+        self.get("/call/api_action/#{action}/format/json/", query_string(action, params))
+      end
+
+      # @param [Hash] params The given action parameters
+      # @return [Hash] Full set of parameters, including generated api parameters
+      def query_string(action, params = {})
+        params.merge generate_api_params(action, params)
+      end
+
+      # @param [Hash] action_params The given action parameters
+      # @return [Hash] required api parameters: [api_key, api_unique, api_timestamp, api_hash]
+      def generate_api_params(action, params = {})
+        {
+          api_key:       public_key,
+          api_unique:    uuid = generate_uuid,
+          api_timestamp: timestamp = Time.now.to_i,
+          api_hash:      generate_hash( timestamp,
+                                        uuid,
+                                        private_key,
+                                        action,
+                                        params.to_json )
+        }
+      end
+
+      # @return [String] SHA256 hash of all the arguments "joined:with:colons"
+      def generate_hash(*args)
+        (Digest::SHA2.new << args.join(':')).to_s
+      end
+
+      # @return [String] Version 4 UUID
+      # More: http://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_.28random.29
+      def generate_uuid
+        SecureRandom.uuid
+      end
+    end
+
+  end
+end

data/lib/hdcore/version.rb

@@ -0,0 +1,3 @@
+module Hdcore
+  VERSION = "0.0.1"
+end

data/lib/hdcore.rb

@@ -0,0 +1,11 @@
+require 'hdcore/version'
+require 'httparty'
+require 'logger'
+require 'yaml'
+require 'json'
+require 'digest/sha2'  # to generate SHA256 hash
+require 'securerandom' # to generate v4 UUID
+
+Dir[File.dirname(__FILE__) + '/hdcore/*.rb'].each do |file|
+  require file
+end

data/spec/lib/hdcore/hdcore_spec.rb

@@ -0,0 +1,71 @@
+require_relative '../../../lib/hdcore'
+
+describe Hdcore do
+
+  describe '.config' do
+    it 'returns hash with expected keys [:api_endpoint, :public_key, :private_key]' do
+      Hdcore.config.keys.should == [:api_endpoint, :public_key, :private_key]
+    end
+
+    it 'returns default [:api_endpoint] => "core.hostdime.com/api/v1"' do
+      Hdcore.config[:api_endpoint].should == 'core.hostdime.com/api/v1'
+    end
+
+    it 'returns default [:public_key] => nil' do
+      Hdcore.config[:public_key].should == nil
+    end
+
+    it 'returns default [:private_key] => nil' do
+      Hdcore.config[:private_key].should == nil
+    end
+  end
+
+  describe '.configure' do
+    it 'assigns value if the key is valid' do
+      # public_key is known to be a valid config key
+      Hdcore.configure(public_key: 'some_value')
+      Hdcore.config[:public_key].should == 'some_value'
+    end
+
+    it 'does nothing for invalid keys' do
+      Hdcore.configure(bogus_key: 'some_value')
+      Hdcore.config[:bogus_key].should be_nil
+    end
+
+    after do
+      # reset to expected nil values
+      Hdcore.configure({
+              public_key:   nil,
+              private_key:  nil
+            })
+    end
+  end
+
+  describe '.missing_config_values?' do
+    it 'returns true by default, due to uninitialized config values' do
+      Hdcore.missing_config_values?.should be_true
+    end
+
+    it 'returns true when a config value is nil' do
+      Hdcore.stub(:config).and_return(some: nil)
+      Hdcore.missing_config_values?.should be_true
+    end
+
+    it 'returns false when config values are not nil' do
+      Hdcore.stub(:config).and_return(some: 'not_nil')
+      Hdcore.missing_config_values?.should be_false
+    end
+  end
+
+  describe '.missing_config_values' do
+    it 'returns default [:public_key, :private_key]' do
+      Hdcore.missing_config_values.should == [:public_key, :private_key]
+    end
+
+    it 'returns keys that have nil values' do
+      Hdcore.stub(:config).and_return(empty_config_key: nil, not_empty: 'value')
+      Hdcore.missing_config_values.should == [:empty_config_key]
+    end
+  end
+
+end

data/spec/lib/hdcore/request_spec.rb

@@ -0,0 +1,86 @@
+require_relative '../../../lib/hdcore'
+
+describe Hdcore::Request do
+
+  describe '.send' do
+    it 'initializes and sends GET request to API endpoint' do
+      test_action = 'some.action'
+      Hdcore::Request.stub(:query_string).and_return(params = {some: 'params'})
+      Hdcore::Request.should_receive(:init)
+      Hdcore::Request.should_receive(:get).with("/call/api_action/#{test_action}/format/json/", params)
+      Hdcore::Request.send(test_action, {})
+    end
+  end
+
+
+  describe '.query_string' do
+    it 'returns parameters merged with generated api parameters' do
+      Hdcore::Request.stub(:generate_api_params).and_return(api_params = {some: 'api_params'})
+      actual = Hdcore::Request.query_string('some.action', params = {some_other: 'params'})
+      actual.should == params.merge(api_params)
+    end
+  end
+
+
+  describe '.generate_api_params' do
+    it 'returns hash with four valid param keys' do
+      actual = Hdcore::Request.generate_api_params("", {})
+      actual.keys.should == [:api_key, :api_unique, :api_timestamp, :api_hash]
+    end
+
+    it 'returns [:api_key] => public key' do
+      Hdcore::Request.stub(:public_key).and_return(key = 'some_public_key')
+      actual = Hdcore::Request.generate_api_params("", {})
+      actual[:api_key].should == key
+    end
+
+    it 'returns [:api_unique] => generated uuid' do
+      Hdcore::Request.stub(:generate_uuid).and_return(uuid = 'some_uuid')
+      actual = Hdcore::Request.generate_api_params("", {})
+      actual[:api_unique].should == uuid
+    end
+
+    it 'returns [:api_timestamp] => time of execution' do
+      timestamp = Time.now.to_i
+      actual = Hdcore::Request.generate_api_params("", {})
+      actual[:api_timestamp].should == timestamp
+    end
+
+    it 'returns [:api_hash] => generated hash' do
+      Hdcore::Request.stub(:generate_hash).and_return(hash = 'some_hash')
+      actual = Hdcore::Request.generate_api_params("", {})
+      actual[:api_hash].should == hash
+    end
+
+
+    it 'generated hash formed with the correct elements: [timestamp, uuid, pkey, action, json-ified params]' do
+      Hdcore::Request.stub(:generate_uuid).and_return(uuid = 'some_uuid')
+      Hdcore::Request.stub(:private_key).and_return(private_key = 'some_private_key')
+
+      Hdcore::Request.should_receive(:generate_hash).with(Time.now.to_i,
+                                                          uuid,
+                                                          private_key,
+                                                          action = 'some.action',
+                                                          (params = {some: 'optional_params'}).to_json
+                                                        )
+
+      Hdcore::Request.generate_api_params(action, params)
+    end
+  end
+
+
+  describe '.generate_hash' do
+    it 'uses the SHA256 algorithm, and joins parameters with colons' do
+      args = %w[one two three 4 five seven 8]
+      hash = (Digest::SHA2.new << args.join(':')).to_s
+      Hdcore::Request.generate_hash(*args).should == hash
+    end
+  end
+
+  describe '.generate_uuid' do
+    it 'uses Version 4 UUID' do
+      SecureRandom.should_receive(:uuid).and_return(uuid = 'some_uuid')
+      Hdcore::Request.generate_uuid.should == uuid
+    end
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification 
+name: hdcore
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ethan Pemble
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-05-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 2
+        - 13
+        version: "2.13"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 11
+        version: "0.11"
+  type: :runtime
+  version_requirements: *id004
+description: A basic wrapper for HostDime's customer portal 'Core' API
+email: 
+- ethan.p@hostdime.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hdcore.gemspec
+- lib/hdcore.rb
+- lib/hdcore/hdcore.rb
+- lib/hdcore/request.rb
+- lib/hdcore/version.rb
+- spec/lib/hdcore/hdcore_spec.rb
+- spec/lib/hdcore/request_spec.rb
+homepage: https://github.com/hostdime/hdcore
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: 
+- spec/lib/hdcore/hdcore_spec.rb
+- spec/lib/hdcore/request_spec.rb