guh 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7d9c96fa741e8caf95a21bd27791fe42948d38e9
+  data.tar.gz: 2b02f5eae38bd78c9c47b934d2480654843ddf3c
+SHA512:
+  metadata.gz: 3d6e69e38dd6833f5a8f6df2bf9d1c2a9ce0513512655f67ea15fb91090df70eda1a75ed6bb34d1e3faf3bc25aedf6e4649babcc21f9fdf79e79ce0aca78700f
+  data.tar.gz: b7534ed8453175c5d4886cafa03322d307d22ab89335571d9a6eef3e9e8d917e1a443b246e10bfe65d380d6cf93bdcf53a78f2fad86d43a5ba2deed80db830bc

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 guh.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 wukerplank
+
+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 @@
+# Guh
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'guh'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install guh
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/HiveFive/guh/fork )
+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,17 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'pp'
+  require 'guh'
+  ARGV.clear
+  IRB.start
+end

data/guh.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'guh/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "guh"
+  spec.version       = Guh::VERSION
+  spec.authors       = ["Christoph Edthofer", "Thomas Esterer"]
+  spec.email         = ["christoph.edthofer@guh.guru", "thomas.esterer@guh.guru"]
+  spec.summary       = %q{The official Ruby wrapper for guh.}
+  spec.description   = "The official Ruby wrapper for guh. guh is an open source home automation system."
+  spec.homepage      = "http://guh.guru"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_dependency "json", "~> 1.8"
+  
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake",    "~> 10.3"
+  spec.add_development_dependency "rspec",   "~> 2.14"
+  spec.add_development_dependency "yard",    "~> 0.8"
+end

data/lib/guh/action.rb

@@ -0,0 +1,34 @@
+module Guh
+  ##
+  # This class wraps everything related to Actions.
+  # 
+  class Action < Base
+    
+    ##
+    # 
+    # Executes a specific Action on a specific Device.
+    # 
+    # To activate an "Elro Power Switch":
+    # 
+    #   Guh::Action.execute("TODO find specific device id", "{31c9758e-6567-4f89-85bb-29e1a7c55d44}", {power: true})
+    # 
+    def self.execute(device_id, action_type_id, params={})
+      response = get({
+        id: generate_request_id,
+        method: "Actions.ExecuteAction",
+        params: {
+          deviceId: device_id,
+          actionTypeId: action_type_id,
+          params: convert_map_to_list_of_maps(params)
+        }
+      })
+      
+      if response['success']==true
+        return response
+      else
+        raise Guh::ArgumentError, response['errorMessage']
+      end
+    end
+    
+  end
+end

data/lib/guh/action_type.rb

@@ -0,0 +1,27 @@
+module Guh
+  ##
+  # This class wraps everything related to ActionTypes.
+  #
+  class ActionType < Base
+    
+    ##
+    # Retrieves all known ActionTypes for a specific Device identified by its +device_id+.
+    #
+    # Example:
+    # 
+    #   Guh::ActionType.all("{308ae6e6-38b3-4b3a-a513-3199da2764f8}")
+    # 
+    def self.all(device_class_id)
+      response = get({
+        id: generate_request_id,
+        method: "Devices.GetActionTypes",
+        params: {
+          deviceClassId: device_class_id
+        }
+      })
+      
+      response['actionTypes']
+    end
+    
+  end
+end

data/lib/guh/base.rb

@@ -0,0 +1,151 @@
+module Guh
+  ##
+  # The base class which all the specific wrapper classes inherit from. It provides some shared code to make development easier.
+  # 
+  class Base
+    
+    # Getter/Setter for the guh_ip_address attribute
+    def self.guh_ip_address #:nodoc:
+      @@guh_ip_address 
+    end
+    def self.guh_ip_address=(hia) #:nodoc:
+      @@guh_ip_address=hia
+    end 
+    @@guh_ip_address = "127.0.0.1"
+    
+    # Getter/Setter for the guh_port attribute
+    def self.guh_port #:nodoc: 
+       @@guh_port
+    end
+    def self.guh_port=(hia) #:nodoc:
+      @@guh_port=hia
+    end
+    @@guh_port = 1234
+    
+    ##
+    # 
+    # Returns everything that is going on inside guh Core
+    # 
+    # Example:
+    # 
+    #   Guh::Base.introspect
+    # 
+    def self.introspect
+      get({
+        id: generate_request_id,
+        method: "JSONRPC.Introspect",
+      })
+    end
+    
+    ##
+    # 
+    # <b>Don't use this unless you know what you are doing!</b>
+    # 
+    # Send a request to guh Core and fetch the Response. This is a utility method used by the subclasses.
+    # 
+    def self.get(request_hash)
+      request_string = hash_to_json(request_hash)
+      
+      response = nil
+      client do |c|
+        c.puts(request_string)
+        
+        response = fetch_message(c)
+      end
+      
+      if response['status']=='success'
+        return response['params']
+      else
+        raise Guh::ResponseError, "The Request was not successful"
+      end
+    end
+    
+    ##
+    # 
+    # Configuration DSL helper method.
+    # 
+    # The default values are: 
+    # * +guh_ip_address+: 127.0.0.1
+    # * +guh_port+: 1234
+    # 
+    # Example:
+    # 
+    #   Guh.configure do |config|
+    #     config.guh_ip_address = 10.0.0.1
+    #     config.guh_port = 6789
+    #   end
+    # 
+    def self.configure(&block)
+      yield self
+    end
+    
+    private
+    
+    def self.generate_request_id
+      999999
+    end
+    
+    def self.client(&block)
+      client = TCPSocket.open(@@guh_ip_address, @@guh_port)
+      
+      connection_message = fetch_message(client)
+      
+      # TODO check guh-core version and raise error if incompatible with this gem's version
+      # TODO look for timeout or connection refused errors
+      
+      yield client
+    end
+    
+    def self.fetch_message(client)
+      end_of_message = false
+      
+      message = ""
+      while (line = client.gets)
+        message << line
+        
+        end_of_message = true if line.match(/^\}\n/)
+        
+        break if end_of_message
+      end
+      
+      return JSON::parse(message)
+    end
+    
+    ##
+    #
+    # Converts a regular hash into a list of hashes.
+    # 
+    # Example: 
+    # 
+    # convert_map_to_list_of_maps({
+    #   power: true,
+    #   pin: 1,
+    #   family_code: 'A'
+    # })
+    #
+    # Returns: 
+    # 
+    # [
+    #   {power: true},
+    #   {pin: 1},
+    #   {family_code: 'A'}
+    # ]
+    # 
+    def self.convert_map_to_list_of_maps(map)
+      # make sure we have an array to work with
+      map ||= []
+      
+      # do the conversion work
+      list = []
+      map.each do |key, value|
+        list << {key => value}
+      end
+      
+      return list
+    end
+    
+    def self.hash_to_json(hash)
+      JSON::dump(hash) + "\n"
+    end
+  end
+end

data/lib/guh/device.rb

@@ -0,0 +1,104 @@
+module Guh
+  ##
+  # This class wraps everything related to configured Devices.
+  #
+  class Device < Base
+    
+    
+    ##
+    #
+    def self.find(id)
+      device = self.all.detect{|d| d['id']==id}
+      
+      return device
+    end
+    
+    ##
+    # 
+    # Returns a list of all configured Devices.
+    # 
+    # Example:
+    # 
+    #   Guh::Device.all
+    # 
+    def self.all
+      response = get({
+        id: generate_request_id,
+        method: "Devices.GetConfiguredDevices"
+      })
+      
+      return response['devices']
+    end
+    
+    ##
+    # 
+    # Creates a configured device and returns it's ID.
+    # 
+    # Example for the "Elro Power Switch":
+    # 
+    #   Guh::Device.add("{308ae6e6-38b3-4b3a-a513-3199da2764f8}", {
+    #     channel1: true,
+    #     channel2: false,
+    #     channel3: false,
+    #     channel4: false,
+    #     channel5: false,
+    #     channel6: true,
+    #     channel7: false,
+    #     channel8: false,
+    #     channel9: false,
+    #     channel10: false
+    #   })
+    # 
+    def self.add(device_class_id, params)
+      response = get({
+        id: generate_request_id,
+        method: "Devices.AddConfiguredDevice",
+        params: {
+          deviceClassId: device_class_id,
+          deviceParams: params
+        }
+      })
+      if response['success']==true
+        return response['deviceId']
+      else
+        raise Guh::ArgumentError, response['errorMessage']
+      end
+    end
+    
+    ##
+    # 
+    # Removes a configured device.
+    # 
+    # Example:
+    #
+    #   device_id = Guh::Device.add("{ab73ad2f-6594-45a3-9063-8f72d365c5e5}", {familyCode: 'A'})
+    #   
+    #   Guh::Device.remove(device_id)
+    # 
+    def self.remove(device_id)
+      response = get({
+        id: generate_request_id,
+        method: "Devices.RemoveConfiguredDevice",
+        params: {
+          deviceId: device_id
+        }
+      })
+      if response['success']==true
+        return true
+      else
+        raise Guh::ResponseError, response['errorMessage']
+      end
+    end
+    
+    ##
+    # 
+    # Returns current number of configured devices
+    # 
+    # Example: Guh::Device.count_configured
+    # 
+    def self.count
+      self.all.length
+    end
+    
+  end
+end

data/lib/guh/device_class.rb

@@ -0,0 +1,70 @@
+module Guh
+  ##
+  # This class wraps everything related to available Devices.
+  #
+  class DeviceClass < Base
+    
+    ##
+    # 
+    # Returns a list of all supported Devices.
+    # 
+    # Example:
+    # 
+    #   Guh::DeviceClass.all
+    #   # => a list of all supported devices
+    # 
+    def self.all(options={})
+      params = {}
+      params['vendorId'] = options[:vendor_id] unless options[:vendor_id].nil?
+      
+      response = get({
+        id: generate_request_id,
+        method: "Devices.GetSupportedDevices",
+        params: params
+      })
+      
+      return response['deviceClasses']
+    end
+    
+    ##
+    #
+    # Finds a DeviceClass with a specific ID
+    # 
+    # Example: 
+    # 
+    #   Guh::DeviceClass.find("{2062d64d-3232-433c-88bc-0d33c0ba2ba6}")
+    #   # => a list of all supported devices of a specific vendor
+    # 
+    def self.find(id)
+      device_classes = self.all
+      
+      device_class = device_classes.detect{|dc| dc['id']==id}
+      
+      if device_class
+        return device_class
+      else
+        raise DeviceClassNotFound, "Could not find a DeviceClass with the id #{id}"
+      end
+    end
+    
+    ##
+    #
+    def self.discover(id, options={})
+      params = {deviceClassId: id}
+      params['discoveryParams'] = options
+      
+      response = get({
+        id: generate_request_id,
+        method: "Devices.GetDiscoveredDevices",
+        params: params
+      })
+      
+      if response['success']
+        return response['deviceDescriptors']
+      else
+        raise ResponseError, response['errorMessage']
+      end
+    end
+    
+  end
+end

data/lib/guh/event.rb

@@ -0,0 +1,9 @@
+module Guh
+  ##
+  # This class wraps everything related to Events.
+  #
+  class Event < Base
+    
+  end
+  
+end

data/lib/guh/event_type.rb

@@ -0,0 +1,28 @@
+module Guh
+  ##
+  # This class wraps everything related to EventTypes.
+  # 
+  class EventType < Base
+    
+    ##
+    # 
+    # Returns a list of all available EventTypes.
+    # 
+    # Example:
+    # 
+    #   Guh::EventType.all(device_class_id)
+    # 
+    def self.all(device_class_id)
+      response = get({
+        id: generate_request_id,
+        method: "Devices.GetEventTypes",
+        params: {
+          deviceClassId: device_class_id
+        }
+      })
+      
+      response['eventTypes']
+    end
+    
+  end
+end

data/lib/guh/plugin.rb

@@ -0,0 +1,44 @@
+module Guh
+  ##
+  # This class wraps everything related to Plugins.
+  # 
+  class Plugin < Base
+    
+    ##
+    # 
+    # Returns a list of all installed plugins.
+    # 
+    # Example:
+    # 
+    #   Guh::Plugin.all
+    # 
+    def self.all
+      response = get({
+        id: generate_request_id,
+        method: "Devices.GetPlugins"
+      })
+      
+      response['plugins']
+    end
+    
+    ##
+    # 
+    # Set some params on a plugin.
+    # 
+    # Example:
+    # 
+    #   HiveRpcWrapper::Plugin.set_params("TODO get proper plugin id", {foo: "bar"})
+    # 
+    # def self.set_config(plugin_id, params)
+    #   get({
+    #     id: generate_request_id,
+    #     method: "Devices.SetPluginConfig",
+    #     params: {
+    #       pluginId: plugin_id,
+    #       params: params
+    #     }
+    #   })
+    # end
+    
+  end
+end

data/lib/guh/rule.rb

@@ -0,0 +1,58 @@
+module Guh
+  ##
+  # This class wraps everything related to Rules.
+  # 
+  class Rule < Base
+    
+    ##
+    # 
+    # Returns a list of all Rules.
+    # 
+    # Example:
+    # 
+    #   Guh::Rule.all
+    # 
+    def self.all
+      response = get({
+        id: generate_request_id,
+        method: "Rules.GetRules"
+      })
+      
+      response['rules']
+    end
+    
+    ##
+    # 
+    # Creates a new Rule.
+    # 
+    # Example:
+    # 
+    #   Guh::Rule.add(event, action)
+    # 
+    def self.add(event, actions)
+      unless actions.is_a?(Array)
+        actions = [actions]
+      end
+      
+      get({
+        id: generate_request_id,
+        method: "Rules.AddRule",
+        event: event,
+        actions: actions
+      })
+    end
+    
+    ##
+    # 
+    # Removes a Rule.
+    # 
+    # Example:
+    # 
+    #   Guh::Rule.remove(rule_id)
+    # 
+    def self.remove(rule_id)
+      
+    end
+    
+  end
+end

data/lib/guh/vendor.rb

@@ -0,0 +1,25 @@
+module Guh
+  ##
+  # This class wraps everything related to Vendors.
+  # 
+  class Vendor < Base
+    
+    ##
+    # 
+    # Retrieves a list of all supported vendors
+    # 
+    # Example:
+    # 
+    #   Guh::Vendor.all
+    # 
+    def self.all
+      response = get({
+        id: generate_request_id,
+        method: "Devices.GetSupportedVendors"
+      })
+      
+      return response['vendors']
+    end
+    
+  end
+end

data/lib/guh/version.rb

@@ -0,0 +1,3 @@
+module Guh
+  VERSION = "0.0.2"
+end

data/lib/guh.rb

@@ -0,0 +1,24 @@
+require "guh/version"
+
+require 'json'
+require 'socket'
+
+require "guh/base"
+require "guh/action_type"
+require "guh/action"
+require "guh/device"
+require "guh/device_class"
+require "guh/event_type"
+require "guh/event"
+require "guh/plugin"
+require "guh/rule"
+require "guh/vendor"
+
+module Guh
+  # Your code goes here...
+  
+  class ConnectionError < Exception; end
+  class ResponseError < Exception; end
+  class ArgumentError < Exception; end
+  
+end

data/spec/helper.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rspec'
+
+require 'guh'
+
+puts "\n\n---------------------------------------------------"
+puts "Please make sure that Guh is running"
+puts "---------------------------------------------------\n\n"
+
+RSpec.configure do |config|
+  config.before(:all) do
+    Guh::Base.configure do |c|
+      c.guh_ip_address = "127.0.0.1"
+      c.guh_port = 1234
+    end
+    
+    # Remove all devices & rules from Guh Core
+    purge_configuration()
+  end
+end
+
+def purge_devices
+  path = File.expand_path('~/.config/guh/guh.conf')
+  File.unlink(path) if File.exist?(path)
+end
+
+def purge_rules
+  path = File.expand_path('~/.config/guh/rules.conf')
+  File.unlink(path) if File.exist?(path)
+end
+
+def purge_configuration
+  purge_devices()
+  purge_rules()
+end
+
+def pj(data)
+  puts ""
+  puts "-"*15
+  puts data.inspect
+  puts "-"*15
+  puts ""
+end
+
+def create_configured_device(device_class_id, params)
+  # Create a device
+  device_id = Guh::Device.add(device_class_id, params)
+  
+  # Get the newly configured device
+  return Guh::Device.all.detect{|d| d['id']==device_id}
+end

data/spec/integration/action_spec.rb

@@ -0,0 +1,42 @@
+require 'helper'
+
+describe Guh::Action do
+  
+  before :all do
+    # Elro Switch
+    device_class_id = "{308ae6e6-38b3-4b3a-a513-3199da2764f8}"
+    
+    @device = create_configured_device(device_class_id, {
+      channel1: true,
+      channel2: false,
+      channel3: false,
+      channel4: false,
+      channel5: false,
+      channel6: false,
+      channel7: false,
+      channel8: false,
+      channel9: false,
+      channel10: false
+    })
+    
+    # Get all the possible actions for the device
+    actions = Guh::ActionType.all(device_class_id)
+    
+    # Just use the first action
+    @action = actions.first
+  end
+  
+  it "should execute a single action" do
+    -> {
+      response = Guh::Action.execute(@device['id'], @action['id'], {power: true})
+    }.should_not raise_error
+  end
+  
+  it 'should fail if the wrong params are provided' do
+    
+    -> {
+      response = Guh::Action.execute(@device['id'], @action['id'], {})
+    }.should raise_error
+  end
+  
+end

data/spec/integration/action_type_spec.rb

@@ -0,0 +1,11 @@
+require 'helper'
+
+describe Guh::ActionType do
+  
+  it "should return the supported actions for a device" do
+    response = Guh::ActionType.all("{308ae6e6-38b3-4b3a-a513-3199da2764f8}")
+    
+    response.should be_an_instance_of(Array)
+  end
+  
+end

data/spec/integration/base_spec.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+describe Guh::Device do
+  
+  it 'should raise an exception if Guh Core is not running' do
+    Guh::Base.configure do |c|
+      c.guh_ip_address = "0.0.0.0"
+      c.guh_port = 7890 # <---- wrong port to provoke excpetion
+    end
+    
+    expect { Guh::Base.introspect }.to raise_error(Errno::ECONNREFUSED)
+  end
+  
+  it 'should raise an exception if Guh Core does not respond with success on connect' do
+    pending("TODO: Find a way to provoke this.")
+  end
+  
+end

data/spec/integration/device_class_spec.rb

@@ -0,0 +1,50 @@
+require 'helper'
+
+describe Guh::DeviceClass do
+  
+  it "should get the supported devices" do
+    response = Guh::DeviceClass.all
+    
+    response.should be_an_instance_of(Array)
+  end
+  
+  it "should find a specific DeviceClass" do
+    device_class_id = "{ab73ad2f-6594-45a3-9063-8f72d365c5e5}"
+    
+    -> {
+      Guh::DeviceClass.find("bogus")
+    }.should raise_error
+    
+    -> {
+      device_class = Guh::DeviceClass.find(device_class_id)
+      device_class['id'].should eq(device_class_id)
+    }.should_not raise_error
+  end
+  
+  it "should get the supported devices of a specific vendor" do
+    response = Guh::Vendor.all
+    
+    vendor_id = response.first['id']
+    
+    devices = Guh::DeviceClass.all(vendor_id: vendor_id)
+    
+    if devices.length > 0
+      devices.first['vendorId'].should eq(vendor_id)
+    end
+  end
+  
+  it "should discover the openweathermap" do
+    
+    device_class_id = "{985195aa-17ad-4530-88a4-cdd753d747d7}"
+    
+    # pending "TODO wait until issue #13 is fixed"
+    
+    device_descriptors = Guh::DeviceClass.discover(device_class_id, location: '')
+    
+    puts "--"
+    puts device_descriptors.inspect
+    puts "--"
+    
+  end
+  
+end

data/spec/integration/device_spec.rb

@@ -0,0 +1,64 @@
+require 'helper'
+
+describe Guh::Device do
+  
+  it "should get the configured device" do
+    response = Guh::Device.all
+    
+    response.should be_an_instance_of(Array)
+  end
+  
+  it "should tell us the number of configured devices" do
+    count = Guh::Device.count
+    
+    count.should be_a(Integer)
+  end
+  
+  it "should let us configure a device" do
+    configured_count = Guh::Device.count
+    
+    -> {
+      response = Guh::Device.add("{308ae6e6-38b3-4b3a-a513-3199da2764f8}", {
+        channel1: true,
+        channel2: false,
+        channel3: false,
+        channel4: false,
+        channel5: false,
+        channel6: false,
+        channel7: false,
+        channel8: false,
+        channel9: false,
+        channel10: false
+      })
+    }.should_not raise_error
+    
+    Guh::Device.count.should eq(configured_count+1)
+  end
+  
+  it "should fail if we omit the params" do
+    configured_count = Guh::Device.count
+    
+    -> {
+      response = Guh::Device.add("{308ae6e6-38b3-4b3a-a513-3199da2764f8}", {})
+    }.should raise_error
+    
+    Guh::Device.count.should eq(configured_count)
+  end
+  
+  it "should create a new device, return its ID and remove it successfully" do
+    device_id = Guh::Device.add("{ab73ad2f-6594-45a3-9063-8f72d365c5e5}", {familyCode: 'A'})
+    
+    device_id.should match(/^\{[a-z0-9\-]+\}$/i)
+    
+    Guh::Device.remove(device_id).should be_true
+    
+    Guh::Device.find(device_id).should be_nil
+  end
+  
+  it "should raise an error if we try to delete a non-existing device" do
+    -> {
+      Guh::Device.remove("abc").should
+    }.should raise_error
+  end
+  
+end

data/spec/integration/event_type_spec.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+describe Guh::EventType do
+  
+  it "should get something back" do
+    # Elro Switch
+    device_class_id = "{308ae6e6-38b3-4b3a-a513-3199da2764f8}"
+    
+    # Get all the possible events for the device
+    response = Guh::EventType.all(device_class_id)
+    
+    response.should be_an_instance_of(Array)
+    
+    pending "Right now we get empty responses for all events"
+  end
+  
+end

data/spec/integration/plugin_spec.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+describe Guh::Plugin do
+  
+  it "should return a list of all loaded plugins" do
+    response = Guh::Plugin.all
+    
+    response.should be_an_instance_of(Array)
+  end
+  
+  it "should add params to the Plugin config" do
+    pending("Implement after difference between PluginConfig & PluginParams is clear")
+  end
+  
+end

data/spec/integration/rule_spec.rb

@@ -0,0 +1,53 @@
+require 'helper'
+
+describe Guh::Rule do
+  
+  before :all do
+    # Intertechno Remote
+    @sender = create_configured_device("{ab73ad2f-6594-45a3-9063-8f72d365c5e5}", {
+      familyCode: 'A'
+    })
+    
+    # Intertechno Switch
+    @receiver = create_configured_device("{324219e8-7c53-41b5-b314-c2900cd15252}", {
+      familyCode: 'A',
+      buttonCode: 1
+    })
+    
+  end
+  
+  it "should return a list of all rules" do
+    response = Guh::Rule.all
+    
+    response.should be_an_instance_of(Array)
+  end
+  
+  it "should create a new rule" do
+    senderDeviceClass = Guh::DeviceClass.all.detect{|d| d['id']==@sender['deviceClassId']}
+    eventId = senderDeviceClass['events'].first['id']
+    
+    actionId = Guh::ActionType.all(@receiver['deviceClassId']).first['id']
+    
+    event = {
+      eventTypeId: eventId,
+      deviceId: @sender['id'],
+      params: {inRange: true}
+    }
+    
+    action = {
+      actionTypeId: actionId,
+      deviceId: @receiver['id'],
+      params: {
+        power: true
+      }
+    }
+    
+    -> {
+      # response = Guh::Rule.add(event, action)
+    }.should_not raise_error
+    
+    pending "TODO How do we know we were successful?"
+    
+  end
+  
+end

data/spec/integration/vendor_spec.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+describe Guh::Vendor do
+  
+  it "should return a list of available vendors" do
+    
+    response = Guh::Vendor.all
+    
+    response.length.should be > 0
+    
+  end
+  
+  it "should return information about a specific vendor" do
+    pending "TODO: Implement Guh::Vendor.find('{abc}')"
+  end
+  
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: guh
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Christoph Edthofer
+- Thomas Esterer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !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.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: The official Ruby wrapper for guh. guh is an open source home automation
+  system.
+email:
+- christoph.edthofer@guh.guru
+- thomas.esterer@guh.guru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- guh.gemspec
+- lib/guh.rb
+- lib/guh/action.rb
+- lib/guh/action_type.rb
+- lib/guh/base.rb
+- lib/guh/device.rb
+- lib/guh/device_class.rb
+- lib/guh/event.rb
+- lib/guh/event_type.rb
+- lib/guh/plugin.rb
+- lib/guh/rule.rb
+- lib/guh/vendor.rb
+- lib/guh/version.rb
+- spec/helper.rb
+- spec/integration/action_spec.rb
+- spec/integration/action_type_spec.rb
+- spec/integration/base_spec.rb
+- spec/integration/device_class_spec.rb
+- spec/integration/device_spec.rb
+- spec/integration/event_type_spec.rb
+- spec/integration/plugin_spec.rb
+- spec/integration/rule_spec.rb
+- spec/integration/vendor_spec.rb
+homepage: http://guh.guru
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- 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.2.2
+signing_key: 
+specification_version: 4
+summary: The official Ruby wrapper for guh.
+test_files:
+- spec/helper.rb
+- spec/integration/action_spec.rb
+- spec/integration/action_type_spec.rb
+- spec/integration/base_spec.rb
+- spec/integration/device_class_spec.rb
+- spec/integration/device_spec.rb
+- spec/integration/event_type_spec.rb
+- spec/integration/plugin_spec.rb
+- spec/integration/rule_spec.rb
+- spec/integration/vendor_spec.rb
+has_rdoc: