kuby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9370fe068bbcbf6b38c2ad3806e73021157a594a
+  data.tar.gz: 010e342da6d058879dbd8b3ffa69a07b9e5b73f2
+SHA512:
+  metadata.gz: 04ab9831be23e1aff218257771c6248f526c8309df40789ca9090fdeeb72a419c96108bab4e1c816f14eb0284ed52558f8bd51ee766bb825b2bdad1ff3a4d584
+  data.tar.gz: 5725160e4ae5582a558245acf55395f66f8bca769c812e5dd5024218ba50183e03f5b66deefa8e63e55c650900926b4e503135112d0c2443816c771f21d4eda6

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/.rvmrc

@@ -0,0 +1 @@
+rvm use --create 2.0.0@kuby

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

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

data/Guardfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ralph Rooding
+
+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,110 @@
+# Kuby
+
+[![Build Status](https://travis-ci.org/rrooding/kuby.png?branch=master)](https://travis-ci.org/rrooding/kuby)
+
+### Crash your Kerbals using Ruby!
+
+Kuby is a Ruby wrapper for the game [Kerbal Space Program](https://kerbalspaceprogram.com/). This gem exposes a simple DSL with which you can control your rockets.
+
+## Installation
+
+Install the gem:
+
+    $ gem install kuby
+    
+Make sure you have a recent version of KSP and also install the [Telemachus plugin](http://kerbalspaceport.com/telemachus/).
+
+## Usage
+
+### Basic example
+
+Create a ruby file with the following contents (simple_launch.rb for example):
+
+	require 'rubygems'
+	require 'kuby'
+	
+	# Optional parameters :host, :port, otherwise defaults will be used (127.0.0.1:8085)
+	link = Kuby::Link.new
+	
+	# Connect to KSP
+	link.connect!
+	
+	# Initiate first stage
+	link.stage!
+	
+	# Set to full throttle
+	link.throttle_full
+	
+	# Activate SAS
+	link.toggle_sas
+	
+Now create a new rocket in KSP or load an existing one. Be sure to add one of the Telemachus antennas to it, otherwise your rocket won't be able to communicate. Now go to the launchpad and when the ship is loaded and you are ready for launch, execute the following command in a terminal:
+
+	$ ruby simple_launch.rb
+	
+Kuby will connect to your rocket and issue the commands in the order you specified in the file, your rocket will activate the first stage, go to full throttle and enable SAS. After that, the script ends but your rocket will keep flying.
+
+### Advanced example
+
+This example will fly your rocket to ± 150 meters and then keeps it floating there by changing the throttle using an implementation of a PID controller
+
+	require 'rubygems'
+	require 'kuby'
+	
+	# Optional parameters :host, :port, otherwise defaults will be used (127.0.0.1:8085)
+	link = Kuby::Link.new
+	
+	# Connect to KSP
+	link.connect!
+	
+	# Initiate first stage
+	link.stage!
+	
+	# Set to full throttle
+	link.throttle_full
+	
+	# Activate SAS
+	link.toggle_sas
+	
+	# Wait untill we're at 150 meters
+	while link.altitude < 150 do
+		sleep 0.2
+	end
+	
+	target = 0.0
+	previous = 0.0
+	error = 0.0
+	integral = 0.0
+	derivative = 0.0
+	time = link.mission_time
+	
+	loop do
+		dt = link.mission_time - time
+		time = link.mission_time
+		error = target - link.vertical_speed
+		integral = integral + error * dt
+		derivative = (error - previous)/dt
+		
+		new_throttle = (error/10 + integral/15 + derivative/30)
+		
+		if new_throttle > 1.0
+			new_throttle = 1.0
+		elsif new_throttle < 0.0
+			new_throttle = 0.0
+		end
+		
+		link.set_throttle new_throttle
+		
+		previous = error
+		
+		sleep 0.2
+	end
+	
+
+## 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,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Default: run rspec'
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new

data/kuby.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kuby/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "kuby"
+  gem.version       = Kuby::VERSION
+  gem.authors       = ["Ralph Rooding"]
+  gem.email         = ["ralph@izerion.com"]
+  gem.description   = %q{Crash your Kerbals using Ruby!}
+  gem.summary       = %q{Crash your Kerbals using Ruby!}
+  gem.homepage      = "https://github.com/rrooding/kuby"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'excon'
+  gem.add_dependency 'multi_json'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'webmock'
+end

data/lib/kuby/link/api_methods.rb

@@ -0,0 +1,9 @@
+module Kuby
+  class Link
+    module ApiMethods
+      def version
+        Gem::Version.new api_get('a.version')
+      end
+    end
+  end
+end

data/lib/kuby/link/flight_methods.rb

@@ -0,0 +1,70 @@
+module Kuby
+  class Link
+    module FlightMethods
+      def abort
+        api_get('f.abort')
+      end
+
+      # Define a method for each of the 10 action groups
+      (1..10).each do |group_no|
+        define_method "actiongroup_#{group_no}" do
+          api_get("f.ag#{group_no}")
+        end
+      end
+
+      def brake
+        api_get('f.brake')
+      end
+
+      def set_throttle(t)
+        if t > 1.0
+          t = 1.0
+        elsif t < 0.0
+          t = 0.0
+        end
+
+        api_set('f.setThrottle', t)
+      end
+
+      def stage!
+        api_get('f.stage')
+      end
+
+      def throttle
+        api_get('f.throttle').to_f
+      end
+
+      def throttle_down
+        api_get('f.throttleDown')
+      end
+
+      def throttle_up
+        api_get('f.throttleUp')
+      end
+
+      def throttle_full
+        api_get('f.throttleFull')
+      end
+
+      def throttle_zero
+        api_get('f.throttleZero')
+      end
+
+      def toggle_gear
+        api_get('f.gear')
+      end
+
+      def toggle_light
+        api_get('f.light')
+      end
+
+      def toggle_rcs
+        api_get('f.rcs')
+      end
+
+      def toggle_sas
+        api_get('f.sas')
+      end
+    end
+  end
+end

data/lib/kuby/link/navbal_methods.rb

@@ -0,0 +1,17 @@
+module Kuby
+  class Link
+    module NavbalMethods
+      def heading
+        api_get('n.heading').to_f
+      end
+
+      def pitch
+        api_get('n.pitch').to_f
+      end
+
+      def roll
+        api_get('n.roll').to_f
+      end
+    end
+  end
+end

data/lib/kuby/link/paused_methods.rb

@@ -0,0 +1,21 @@
+module Kuby
+  class Link
+    module PausedMethods
+      PAUSE_STATES = [:not_paused, :flight_paused, :out_of_power, :antenna_disabled, :vessel_wo_antenna, :unknown_pause_state]
+
+      def paused?
+        pause_value > 0
+      end
+
+      def pause_state
+        PAUSE_STATES[pause_value]
+      end
+
+      private
+
+      def pause_value
+        api_get('p.paused').to_i
+      end
+    end
+  end
+end

data/lib/kuby/link/vessel_methods.rb

@@ -0,0 +1,73 @@
+module Kuby
+  class Link
+    module VesselMethods
+      def altitude
+        api_get('v.altitude').to_f
+      end
+
+      def height
+        api_get('v.heightFromTerrain').to_f
+      end
+
+      def terrain_height
+        api_get('v.terrainHeight').to_f
+      end
+
+      def mission_time
+        api_get('v.missionTime').to_f
+      end
+
+      def surface_velocity
+        api_get('v.surfaceVelocity').to_f
+      end
+
+      def surface_velocity_x
+        api_get('v.surfaceVelocityx').to_f
+      end
+
+      def surface_velocity_y
+        api_get('v.surfaceVelocityy').to_f
+      end
+
+      def surface_velocity_z
+        api_get('v.surfaceVelocityz').to_f
+      end
+
+      def angular_velocity
+        api_get('v.angularVelocity').to_f
+      end
+
+      def orbital_velocity
+        api_get('v.orbitalVelocity').to_f
+      end
+
+      def surface_speed
+        api_get('v.surfaceSpeed').to_f
+      end
+
+      def vertical_speed
+        api_get('v.verticalSpeed').to_f
+      end
+
+      def atmospheric_density
+        api_get('v.atmosphericDensity').to_f
+      end
+
+      def lat
+        api_get('v.lat')
+      end
+
+      def long
+        api_get('v.long')
+      end
+
+      def dynamic_pressure
+        api_get('v.dynamicPressure').to_f
+      end
+
+      def name
+        api_get('v.name')
+      end
+    end
+  end
+end

data/lib/kuby/link.rb

@@ -0,0 +1,62 @@
+require 'multi_json'
+require 'kuby/link/api_methods'
+require 'kuby/link/flight_methods'
+require 'kuby/link/navbal_methods'
+require 'kuby/link/paused_methods'
+require 'kuby/link/vessel_methods'
+
+class Kuby::Link
+  MIN_TELEMACHUS_VERSION = Gem::Version.new('1.4.6.0')
+
+  attr_reader :host, :port
+
+  include Kuby::Link::ApiMethods
+  include Kuby::Link::FlightMethods
+  include Kuby::Link::NavbalMethods
+  include Kuby::Link::PausedMethods
+  include Kuby::Link::VesselMethods
+
+  def initialize(options={})
+    @host = options.fetch(:host, '127.0.0.1')
+    @port = options.fetch(:port, 8085).to_i
+    @path = 'telemachus/datalink'
+  end
+
+  def connect!
+    # Raise error when the telemachus version is not supported, this also automatically
+    # checks if the connection can be made
+    unless supported_version?
+      raise Kuby::UnsupportedTelemachusVersion.new("Please install Telemachus #{MIN_TELEMACHUS_VERSION} or higher")
+    end
+
+    true
+  end
+
+  private
+
+  def api_set(ret, *args)
+    api_get("#{ret}[#{args.join(',')}]")
+  end
+
+  def api_get(ret)
+    # All Telemachus api methods are GET, the api command is passed in as the 'ret' parameter,
+    # the returned result is in the form of: {"ret":"<value>"}
+    res = Excon.get(uri, { tcp_nodelay: true, query: "ret=#{ret}" })
+
+    # Parse the result
+    data = MultiJson.load(res.body, symbolize_keys: true)
+
+    data[:ret]
+  rescue Excon::Errors::SocketError, Errno::ECONNREFUSED
+    # Catch different kinds of connection refused and raise custom exception
+    raise Kuby::TelemachusConnectionRefused
+  end
+
+  def supported_version?
+    version >= MIN_TELEMACHUS_VERSION
+  end
+
+  def uri
+    @uri ||= "http://#{@host}:#{@port}/#{@path}"
+  end
+end

data/lib/kuby/version.rb

@@ -0,0 +1,3 @@
+module Kuby
+  VERSION = "0.1.0"
+end

data/lib/kuby.rb

@@ -0,0 +1,8 @@
+require 'kuby/version'
+require 'kuby/link'
+
+module Kuby
+  class UnsupportedTelemachusVersion < StandardError; end
+  class ConnectionNotEstablished < StandardError; end
+  class TelemachusConnectionRefused < StandardError; end
+end

data/spec/kuby/link/api_methods_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+class DummyClass
+end
+
+describe Kuby::Link::ApiMethods do
+  subject { DummyClass.new }
+
+  before do
+    subject.extend Kuby::Link::ApiMethods
+    subject.stub(:api_get)
+  end
+
+  describe '#version' do
+    it 'implements the a.version call' do
+      subject.should_receive(:api_get).with('a.version')
+
+      subject.version
+    end
+
+    it 'returns a Gem::Version instance' do
+      expect(subject.version).to be_an_instance_of Gem::Version
+    end
+
+    it 'sets the version to the returned version' do
+      subject.stub(:api_get).and_return('1.2.3.4')
+
+      expect(subject.version.to_s).to eq '1.2.3.4'
+    end
+  end
+end

data/spec/kuby/link/flight_methods_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+class DummyClass
+end
+
+describe Kuby::Link::FlightMethods do
+  subject { DummyClass.new }
+
+  before do
+    subject.extend Kuby::Link::FlightMethods
+    subject.stub(:api_get)
+  end
+
+  describe '#abort' do
+    it 'implements the f.abort call' do
+      subject.should_receive(:api_get).with('f.abort')
+
+      subject.abort
+    end
+  end
+
+  (1..10).each do |group_no|
+    describe "#actiongroup_#{group_no}" do
+      it "implements the f.ag#{group_no} call" do
+        subject.should_receive(:api_get).with("f.ag#{group_no}")
+
+        subject.send("actiongroup_#{group_no}")
+      end
+    end
+  end
+
+  describe '#brake' do
+    it 'implements the f.brake call' do
+      subject.should_receive(:api_get).with('f.brake')
+
+      subject.brake
+    end
+  end
+
+  describe '#set_throttle' do
+    it 'implements the f.setThrottle call' do
+      subject.should_receive(:api_set).with('f.setThrottle', 0.5)
+
+      subject.set_throttle(0.5)
+    end
+
+    context 'throttle is larger than 1' do
+      it 'normalizes to 1.0' do
+        subject.should_receive(:api_set).with('f.setThrottle', 1.0)
+
+        subject.set_throttle(123)
+      end
+    end
+
+    context 'throttle is not a float or int' do
+      it 'raises an ArgumentError' do
+        expect {
+          subject.set_throttle('a')
+        }.to raise_error ArgumentError
+      end
+    end
+
+    context 'throttle is smaller than 0' do
+      it 'normalizes to 0.0' do
+        subject.should_receive(:api_set).with('f.setThrottle', 0.0)
+
+        subject.set_throttle(-0.4)
+      end
+    end
+  end
+
+  describe '#stage!' do
+    it 'implements the f.stage call' do
+      subject.should_receive(:api_get).with('f.stage')
+
+      subject.stage!
+    end
+  end
+
+  describe '#throttle' do
+    it 'implements the f.throttle call' do
+      subject.should_receive(:api_get).with('f.throttle')
+
+      subject.throttle
+    end
+
+    it 'returns a float' do
+      expect(subject.throttle).to be_an_instance_of Float
+    end
+  end
+
+  describe '#throttle_down' do
+    it 'implements the f.throttleDown call' do
+      subject.should_receive(:api_get).with('f.throttleDown')
+
+      subject.throttle_down
+    end
+  end
+
+  describe '#throttle_up' do
+    it 'implements the f.throttleUp call' do
+      subject.should_receive(:api_get).with('f.throttleUp')
+
+      subject.throttle_up
+    end
+  end
+
+  describe '#throttle_full' do
+    it 'implements the f.throttleFull call' do
+      subject.should_receive(:api_get).with('f.throttleFull')
+
+      subject.throttle_full
+    end
+  end
+
+  describe '#throttle_zero' do
+    it 'implements the f.throttleZero call' do
+      subject.should_receive(:api_get).with('f.throttleZero')
+
+      subject.throttle_zero
+    end
+  end
+
+  describe '#toggle_gear' do
+    it 'implements the f.gear call' do
+      subject.should_receive(:api_get).with('f.gear')
+
+      subject.toggle_gear
+    end
+  end
+
+  describe '#toggle_light' do
+    it 'implements the f.light call' do
+      subject.should_receive(:api_get).with('f.light')
+
+      subject.toggle_light
+    end
+  end
+
+  describe '#toggle_rcs' do
+    it 'implements the f.rcs call' do
+      subject.should_receive(:api_get).with('f.rcs')
+
+      subject.toggle_rcs
+    end
+  end
+
+  describe '#toggle_sas' do
+    it 'implements the f.sas call' do
+      subject.should_receive(:api_get).with('f.sas')
+
+      subject.toggle_sas
+    end
+  end
+end

data/spec/kuby/link/navbal_methods_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+class DummyClass
+end
+
+describe Kuby::Link::NavbalMethods do
+  subject { DummyClass.new }
+
+  before do
+    subject.extend Kuby::Link::NavbalMethods
+    subject.stub(:api_get)
+  end
+
+  describe '#heading' do
+    it 'implements the n.heading call' do
+      subject.should_receive(:api_get).with('n.heading')
+
+      subject.heading
+    end
+
+    it 'returns a float' do
+      expect(subject.heading).to be_an_instance_of Float
+    end
+  end
+
+  describe '#pitch' do
+    it 'implements the n.pitch call' do
+      subject.should_receive(:api_get).with('n.pitch')
+
+      subject.pitch
+    end
+
+    it 'returns a float' do
+      expect(subject.pitch).to be_an_instance_of Float
+    end
+  end
+
+  describe '#roll' do
+    it 'implements the n.roll call' do
+      subject.should_receive(:api_get).with('n.roll')
+
+      subject.roll
+    end
+
+    it 'returns a float' do
+      expect(subject.roll).to be_an_instance_of Float
+    end
+  end
+end

data/spec/kuby/link/paused_methods_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+class DummyClass
+end
+
+describe Kuby::Link::PausedMethods do
+  subject { DummyClass.new }
+
+  before do
+    subject.extend Kuby::Link::PausedMethods
+    subject.stub(:api_get)
+  end
+
+  describe '#paused?' do
+    it 'implements the p.paused call' do
+      subject.should_receive(:api_get).with('p.paused')
+
+      subject.paused?
+    end
+
+    context 'ret is non-zero' do
+      before do
+        subject.stub(:api_get).and_return '1'
+      end
+
+      it 'returns true' do
+        expect(subject).to be_paused
+      end
+    end
+
+    context 'ret is zero' do
+      before do
+        subject.stub(:api_get).and_return '0'
+      end
+
+      it 'returns false' do
+        expect(subject).to_not be_paused
+      end
+    end
+  end
+
+  describe '#pause_state' do
+    context 'not paused' do
+      before do
+        subject.stub(:api_get).and_return '0'
+      end
+
+      it 'returns :not_paused' do
+        expect(subject.pause_state).to be :not_paused
+      end
+    end
+
+    context 'flight paused' do
+      before do
+        subject.stub(:api_get).and_return '1'
+      end
+
+      it 'returns :flight_paused' do
+        expect(subject.pause_state).to be :flight_paused
+      end
+    end
+
+    context 'out of power' do
+      before do
+        subject.stub(:api_get).and_return '2'
+      end
+
+      it 'returns :out_of_power' do
+        expect(subject.pause_state).to be :out_of_power
+      end
+    end
+
+    context 'antenna disabled' do
+      before do
+        subject.stub(:api_get).and_return '3'
+      end
+
+      it 'returns :antenna_disabled' do
+        expect(subject.pause_state).to be :antenna_disabled
+      end
+    end
+
+    context 'vessel without antenna' do
+      before do
+        subject.stub(:api_get).and_return '4'
+      end
+
+      it 'returns :vessel_wo_antenna' do
+        expect(subject.pause_state).to be :vessel_wo_antenna
+      end
+    end
+
+    context 'unknown pause state' do
+      before do
+        subject.stub(:api_get).and_return '5'
+      end
+
+      it 'returns :unknown_pause_state' do
+        expect(subject.pause_state).to be :unknown_pause_state
+      end
+    end
+  end
+end

data/spec/kuby/link/vessel_methods_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+class DummyClass
+end
+
+describe Kuby::Link::VesselMethods do
+  subject { DummyClass.new }
+
+  before do
+    subject.extend Kuby::Link::VesselMethods
+    subject.stub(:api_get)
+  end
+
+  describe '#altitude' do
+    it 'implements the v.altitude call' do
+      subject.should_receive(:api_get).with('v.altitude')
+
+      subject.altitude
+    end
+
+    it 'returns a float' do
+      expect(subject.altitude).to be_an_instance_of Float
+    end
+  end
+
+  describe '#height' do
+    it 'implements the v.heightFromTerrain call' do
+      subject.should_receive(:api_get).with('v.heightFromTerrain')
+
+      subject.height
+    end
+
+    it 'returns a float' do
+      expect(subject.height).to be_an_instance_of Float
+    end
+  end
+
+  describe '#terrain_height' do
+    it 'implements the v.terrainHeight call' do
+      subject.should_receive(:api_get).with('v.terrainHeight')
+
+      subject.terrain_height
+    end
+
+    it 'returns a float' do
+      expect(subject.terrain_height).to be_an_instance_of Float
+    end
+  end
+
+  describe '#mission_time' do
+    it 'implements the v.missionTime call' do
+      subject.should_receive(:api_get).with('v.missionTime')
+
+      subject.mission_time
+    end
+
+    it 'returns a float' do
+      expect(subject.mission_time).to be_an_instance_of Float
+    end
+  end
+
+  describe '#surface_velocity' do
+    it 'implements the v.surfaceVelocity call' do
+      subject.should_receive(:api_get).with('v.surfaceVelocity')
+
+      subject.surface_velocity
+    end
+
+    it 'returns a float' do
+      expect(subject.surface_velocity).to be_an_instance_of Float
+    end
+  end
+
+  describe '#surface_velocity_x' do
+    it 'implements the v.surfaceVelocityx call' do
+      subject.should_receive(:api_get).with('v.surfaceVelocityx')
+
+      subject.surface_velocity_x
+    end
+
+    it 'returns a float' do
+      expect(subject.surface_velocity_x).to be_an_instance_of Float
+    end
+  end
+
+  describe '#surface_velocity_y' do
+    it 'implements the v.surfaceVelocityy call' do
+      subject.should_receive(:api_get).with('v.surfaceVelocityy')
+
+      subject.surface_velocity_y
+    end
+
+    it 'returns a float' do
+      expect(subject.surface_velocity_y).to be_an_instance_of Float
+    end
+  end
+
+  describe '#surface_velocity_z' do
+    it 'implements the v.surfaceVelocityz call' do
+      subject.should_receive(:api_get).with('v.surfaceVelocityz')
+
+      subject.surface_velocity_z
+    end
+
+    it 'returns a float' do
+      expect(subject.surface_velocity_z).to be_an_instance_of Float
+    end
+  end
+
+  describe '#angular_velocity' do
+    it 'implements the v.angularVelocity call' do
+      subject.should_receive(:api_get).with('v.angularVelocity')
+
+      subject.angular_velocity
+    end
+
+    it 'returns a float' do
+      expect(subject.angular_velocity).to be_an_instance_of Float
+    end
+  end
+
+  describe '#orbital_velocity' do
+    it 'implements the v.orbitalVelocity call' do
+      subject.should_receive(:api_get).with('v.orbitalVelocity')
+
+      subject.orbital_velocity
+    end
+
+    it 'returns a float' do
+      expect(subject.orbital_velocity).to be_an_instance_of Float
+    end
+  end
+
+  describe '#surface_speed' do
+    it 'implements the v.surfaceSpeed call' do
+      subject.should_receive(:api_get).with('v.surfaceSpeed')
+
+      subject.surface_speed
+    end
+
+    it 'returns a float' do
+      expect(subject.surface_speed).to be_an_instance_of Float
+    end
+  end
+
+  describe '#vertical_speed' do
+    it 'implements the v.verticalSpeed call' do
+      subject.should_receive(:api_get).with('v.verticalSpeed')
+
+      subject.vertical_speed
+    end
+
+    it 'returns a float' do
+      expect(subject.vertical_speed).to be_an_instance_of Float
+    end
+  end
+
+  describe '#atmospheric_density' do
+    it 'implements the v.atmosphericDensity call' do
+      subject.should_receive(:api_get).with('v.atmosphericDensity')
+
+      subject.atmospheric_density
+    end
+
+    it 'returns a float' do
+      expect(subject.atmospheric_density).to be_an_instance_of Float
+    end
+  end
+
+  describe '#lat' do
+    it 'implements the v.lat call' do
+      subject.should_receive(:api_get).with('v.lat')
+
+      subject.lat
+    end
+  end
+
+  describe '#long' do
+    it 'implements the v.long call' do
+      subject.should_receive(:api_get).with('v.long')
+
+      subject.long
+    end
+  end
+
+  describe '#dynamic_pressure' do
+    it 'implements the v.dynamicPressure call' do
+      subject.should_receive(:api_get).with('v.dynamicPressure')
+
+      subject.dynamic_pressure
+    end
+
+    it 'returns a float' do
+      expect(subject.dynamic_pressure).to be_an_instance_of Float
+    end
+  end
+
+  describe '#name' do
+    it 'implements the v.name call' do
+      subject.should_receive(:api_get).with('v.name')
+
+      subject.name
+    end
+  end
+end

data/spec/kuby/link_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Kuby::Link do
+  subject { Kuby::Link.new }
+
+  describe '#initialize' do
+    context 'without options' do
+      it 'sets the host to the default' do
+        expect(subject.host).to eq '127.0.0.1'
+      end
+
+      it 'sets the port to default' do
+        expect(subject.port).to eq 8085
+      end
+    end
+
+    context 'with host' do
+      subject { Kuby::Link.new(host: 'kerbalhost.com') }
+
+      it 'sets the host to the given value' do
+        expect(subject.host).to eq 'kerbalhost.com'
+      end
+    end
+
+    context 'with port' do
+      subject { Kuby::Link.new(port: 1234) }
+
+      it 'sets the port to the given value' do
+        expect(subject.port).to eq 1234
+      end
+    end
+  end
+
+  describe '#connect!' do
+    context 'unsupported version' do
+      before do
+        stub_request(:get, /ret=a.version\z/).to_return({status: 200, body: '{"ret":"1.4.5.0"}'})
+      end
+
+      it 'raises a Kuby::UnsupportedTelemachusVersion exception' do
+        expect {
+          subject.connect!
+        }.to raise_error Kuby::UnsupportedTelemachusVersion
+      end
+    end
+
+    context 'connection refused' do
+      before do
+        stub_request(:get, /.+/).to_raise(Errno::ECONNREFUSED)
+      end
+
+      it 'raises a Kuby::TelemachusConnectionRefused exception' do
+        expect {
+          subject.connect!
+        }.to raise_error Kuby::TelemachusConnectionRefused
+      end
+    end
+
+    context 'connection ok' do
+       it 'returns true' do
+         expect(subject.connect!).to be_true
+       end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'rspec'
+require 'webmock/rspec'
+require 'kuby'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    stub_request(:get, /ret=a.version\z/).to_return({status: 200, body: '{"ret":"1.4.6.0"}'})
+  end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: kuby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ralph Rooding
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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
+  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: guard-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: webmock
+  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'
+description: Crash your Kerbals using Ruby!
+email:
+- ralph@izerion.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- kuby.gemspec
+- lib/kuby.rb
+- lib/kuby/link.rb
+- lib/kuby/link/api_methods.rb
+- lib/kuby/link/flight_methods.rb
+- lib/kuby/link/navbal_methods.rb
+- lib/kuby/link/paused_methods.rb
+- lib/kuby/link/vessel_methods.rb
+- lib/kuby/version.rb
+- spec/kuby/link/api_methods_spec.rb
+- spec/kuby/link/flight_methods_spec.rb
+- spec/kuby/link/navbal_methods_spec.rb
+- spec/kuby/link/paused_methods_spec.rb
+- spec/kuby/link/vessel_methods_spec.rb
+- spec/kuby/link_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/rrooding/kuby
+licenses: []
+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.0.6
+signing_key: 
+specification_version: 4
+summary: Crash your Kerbals using Ruby!
+test_files:
+- spec/kuby/link/api_methods_spec.rb
+- spec/kuby/link/flight_methods_spec.rb
+- spec/kuby/link/navbal_methods_spec.rb
+- spec/kuby/link/paused_methods_spec.rb
+- spec/kuby/link/vessel_methods_spec.rb
+- spec/kuby/link_spec.rb
+- spec/spec_helper.rb