cukunity 0.1.0

data/lib/cukunity/unity/client_methods.rb

@@ -0,0 +1,46 @@
+require 'json'
+require 'singleton'
+
+module Cukunity
+  module Unity
+    module ClientMethods
+      include Cukunity::Utils
+      include Cukunity::Unity::CommandFacade
+      include Cukunity::RequestLineResponseClientMethods
+      alias_method :request_connect, :connect
+
+      DEFAULT_HOSTNAME = '127.0.0.1'
+      DEFAULT_PORT = 9921
+
+      def command(name, opts = {})
+        req = opts.merge({'command' => name})
+        res = request(req.to_json) do |line|
+          JSON.parse(line)
+        end
+        raise Exception::UnityCommandError.new(res['error']) if res.nil? or res.has_key?('error')
+        res
+      end
+
+      private
+      def connect(host = DEFAULT_HOSTNAME, port = DEFAULT_PORT)
+        request_connect(host, port) do |socket|
+          if (line = socket.gets).nil?
+            # close and try again
+            close
+          else
+            JSON.parse(line).tap do |ack|
+              raise Exception::UnityInvalidAck.new if ack != {}
+            end
+          end
+        end
+      end
+
+      def self.included(base)
+        # include Singleton methods in the base class
+        base.class_eval do
+          include Singleton
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/unity/command_facade.rb

@@ -0,0 +1,67 @@
+module Cukunity
+  module Unity
+    module CommandFacade
+      def screen
+        Unity::Screen.new(self, command('get_screen'))
+      end
+
+      def level
+        Unity::Level.new(command('get_level'))
+      end
+
+      def load_level(level, max_time = 30)
+        level_was_loaded = nil
+        options = 
+          if level.is_a? String
+            level_was_loaded = lambda do
+              self.level.name == level
+            end
+            { 'name' => level }
+          else
+            level_was_loaded = lambda do
+              self.level.number == level.to_i
+            end
+            { 'number' => level.to_i }
+          end
+        Unity::Scene.new(self, command('load_level', options))
+        raise Exception::UnityCommandError.new if check_timeout(max_time) do
+          level_was_loaded.call
+        end
+      end
+
+      def scene 
+        Unity::Scene.new(self, command('get_scene'))
+      end
+
+      def gameobjects
+        scene.gameobjects
+      end
+
+      def gameobject(name)
+        gameobjects.find do |gameobject|
+          gameobject.value_of('name') == name
+        end
+      end
+
+      def components(options = {})
+        options = merge_options(options, { :recursive => true })
+        gameobjects.inject([]) do |components, gameobject|
+          components + gameobject.components(options)
+        end
+      end
+
+      def hints(options = {})
+        options = merge_options(options, { :recursive => true })
+        gameobjects.inject([]) do |hints, gameobject|
+          hints + gameobject.hints(options)
+        end
+      end
+
+      def hint(options = {})
+        hints(options).find do |h|
+          yield h
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/unity/component.rb

@@ -0,0 +1,39 @@
+module Cukunity
+  module Unity
+    class Component < Unity::JSONContainer
+      attr_reader :gameobject
+
+      def initialize(json, gameobject)
+        super(json)
+        @gameobject = gameobject 
+      end
+
+      def hint(*args)
+        hints(*args).first
+      end
+
+      def has_hint?(*args)
+        !hint(*args).nil?
+      end
+
+      def hints(options = {})
+        # memoize all hints
+        if @hints.nil?
+          @hints = (value_of('.hints') || []).inject([]) do |hints, json|
+            type = json[0]
+            values = json[1]
+            hints + values.map do |json|
+              Unity::Hint.new(json, type, self)
+            end
+          end
+        end
+        options = merge_options(options, { :type => nil })
+        return @hints if options[:type].nil?
+        # select desired hints
+        @hints.select do |hint|
+          options[:type].to_s == hint.type
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/unity/gameobject.rb

@@ -0,0 +1,53 @@
+module Cukunity
+  module Unity
+    class GameObject < Unity::JSONContainer
+      attr_reader :scene
+      attr_reader :parent
+
+      def initialize(json, scene, parent = nil)
+        super(json)
+        @scene = scene
+        @parent = parent
+      end
+
+      def children
+        @children ||= (value_of('children') || []).map do |json|
+          Unity::GameObject.new(json, @scene, self)
+        end
+      end
+
+      def component(*args)
+        components(*args).first
+      end
+
+      def has_component?(*args)
+        !!component(*args)
+      end
+
+      def components(options = {})
+        # memoize all components
+        if @components.nil?
+          @components = (value_of('components') || []).map do |json|
+            Unity::Component.new(json, self)
+          end
+          @components += children.inject([]) do |components, child|
+            components + child.components(:recursive => true)
+          end
+        end
+        options = merge_options(options, { :recursive => false })
+        # select desired components
+        @components.select do |component|
+          acceptable_type = (options[:type].nil? or options[:type] == component.type)
+          acceptable_type and (options[:recursive] or component.gameobject == self)
+        end
+      end
+
+      def hints(options = {})
+        options = merge_options(options, { :recursive => false })
+        components(restrict_options(options, :recursive)).inject([]) do |hints, component|
+          hints + component.hints(options)
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/unity/hint.rb

@@ -0,0 +1,27 @@
+module Cukunity
+  module Unity
+    class Hint < Unity::JSONContainer
+      include ScreenHintMethods
+      include TextHintMethods
+
+      attr_reader :component
+      attr_reader :type
+      attr_reader :value
+
+      def initialize(json, type, component)
+        super(json)
+        @type = type
+        @value = json
+        @component = component 
+      end
+
+      def gameobject
+        component.gameobject
+      end
+
+      def to_s
+        { type.to_s => json }.to_s
+      end
+    end
+  end
+end

data/lib/cukunity/unity/json_container.rb

@@ -0,0 +1,48 @@
+module Cukunity
+  module Unity
+    class JSONContainer
+      include Cukunity::Utils
+      attr_reader :json
+
+      def initialize(json)
+        @json = json
+      end
+
+      def value_of(key)
+        @json[key.to_s]
+      end
+
+      alias_method :[], :value_of
+      alias_method :property, :value_of
+
+      def keys
+        @json.keys
+      end
+
+      alias_method :properties, :keys
+
+      def has_key?(key)
+        @json.has_key?(key.to_s)
+      end
+
+      alias_method :has_property?, :has_key?
+
+      # inspect json structure dynamically
+      def method_missing(meth, *args, &block)
+        if json.is_a? Hash
+          meth = meth.to_s
+          return property(meth) if has_property?(meth)
+          if meth[-1..-1] == '?'
+            meth = meth[0...-1]
+            return !!property(meth) if has_property?(meth)
+          end
+        end
+        super
+      end
+
+      def to_s
+        @json.to_s
+      end
+    end
+  end
+end

data/lib/cukunity/unity/level.rb

@@ -0,0 +1,6 @@
+module Cukunity
+  module Unity
+    class Level < Unity::JSONContainer
+    end
+  end
+end

data/lib/cukunity/unity/scene.rb

@@ -0,0 +1,18 @@
+module Cukunity
+  module Unity
+    class Scene < Unity::JSONContainer
+      attr_reader :client
+
+      def initialize(client, *args)
+        @client = client
+        super(*args)
+      end
+
+      def gameobjects
+        @gameobjects ||= (value_of('gameObjects') || []).map do |json|
+          Unity::GameObject.new(json, self)
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/unity/screen.rb

@@ -0,0 +1,45 @@
+module Cukunity
+  module Unity
+    class Screen < Unity::JSONContainer
+      attr_reader :client
+
+      def initialize(client, *args)
+        @client = client
+        super(*args)
+      end
+
+      def tap(pos, options = {})
+        options = invert_y(pos, options)
+        options[:type] = :tap
+        client.platform::TouchInput.touch_screen(options)
+      end
+
+      def touch_down(pos, options = {})
+        options = invert_y(pos, options)
+        options[:down] = :down
+        client.platform::TouchInput.touch_screen(options)
+      end
+
+      def touch_release(pos, options = {})
+        options = invert_y(pos, options)
+        options[:up] = :up
+        client.platform::TouchInput.touch_screen(options)
+      end
+
+      def touch_move(pos, options = {})
+        options = invert_y(pos, options)
+        options[:move] = :move
+        client.platform::TouchInput.touch_screen(options)
+      end
+
+      alias_method :touch_up, :touch_release
+
+      private
+      def invert_y(pos, options)
+        merge_options(pos, options).tap do |options|
+          options[:y] = value_of('height') - options[:y]
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/unity/screen_hint_methods.rb

@@ -0,0 +1,61 @@
+module Cukunity
+  module Unity
+    module ScreenHintMethods
+      def screen_pos(options = {})
+        options = merge_options(options, { :horizontal => :center, :vertical => :center })
+        pos = {}
+        case options[:horizontal]
+        when :left
+          pos[:x] = value_of('x').to_i
+        when :right
+          pos[:x] = (value_of('x') + value_of('width')).to_i
+        else
+          pos[:x] = (value_of('x') + value_of('width') / 2).to_i
+        end
+        case options[:vertical]
+        when :bottom
+          pos[:y] = value_of('y').to_i
+        when :top
+          pos[:y] = (value_of('y') + value_of('height')).to_i
+        else
+          pos[:y] = (value_of('y') + value_of('height') / 2).to_i
+        end
+        pos
+      end
+
+      def rect
+        { :x => value_of('x'), :y => value_of('y'),
+          :width => value_of('width'), :height => value_of('height') }
+      end
+
+      def on_screen?
+        return false unless component.enabled? and gameobject.active?
+        intersects?(gameobject.scene.client.screen.json)
+      end
+
+      def intersects?(arg)
+        _rect2 =
+          if arg.kind_of? Hash
+            merge_options(arg, { :x => 0, :y => 0, :width => 0, :height => 0 })
+          else
+            arg.rect
+          end
+        _rect = self.rect
+        # completely to the left?
+        return false if (_rect[:x] + _rect[:width]) <= _rect2[:x] 
+        # completely to the right?
+        return false if _rect[:x] >= (_rect2[:x] + _rect2[:width])
+        # completely above?
+        return false if (_rect[:y] + _rect[:height]) <= _rect2[:y] 
+        # completely below?
+        return false if _rect[:y] >= (_rect2[:y] + _rect2[:height])
+        # prove by contradiction
+        true
+      end
+
+      def tap(options = {})
+        gameobject.scene.client.screen.tap screen_pos(options), options
+      end
+    end
+  end
+end

data/lib/cukunity/unity/text_hint_methods.rb

@@ -0,0 +1,17 @@
+module Cukunity
+  module Unity
+    module TextHintMethods
+      def text
+        json
+      end
+
+      def reads_as?(text)
+        text.to_s == self.text 
+      end
+
+      def reads_like?(regexp)
+        !text.match(regexp).nil?
+      end
+    end
+  end
+end

data/lib/cukunity/unity.rb

@@ -0,0 +1,11 @@
+require 'cukunity/unity/command_facade'
+require 'cukunity/unity/client_methods'
+require 'cukunity/unity/json_container'
+require 'cukunity/unity/screen'
+require 'cukunity/unity/level'
+require 'cukunity/unity/scene'
+require 'cukunity/unity/gameobject'
+require 'cukunity/unity/component'
+require 'cukunity/unity/text_hint_methods'
+require 'cukunity/unity/screen_hint_methods'
+require 'cukunity/unity/hint'

data/lib/cukunity/utils.rb

@@ -0,0 +1,56 @@
+require 'timeout'
+
+module Cukunity
+  module Utils
+    def check_timeout(max_time, delay = 0.1)
+      start = Time.now
+      until yield
+        if (Time.now > (start + max_time))
+          return true
+        end
+        sleep delay
+      end
+      false
+    end
+
+    # adapted from Rails
+    def to_options(hash)
+      raise "Expected a hash but got a #{hash.class}" unless hash.instance_of? Hash
+      hash_dup = hash.dup
+      hash_dup.keys.each do |key|
+        hash_dup[(key.to_sym rescue key) || key] = hash_dup.delete(key)
+      end
+      hash_dup
+    end
+
+    def merge_options(options, defaults = {})
+      to_options(defaults).merge(to_options(options))
+    end
+
+    def restrict_options(options, *restricted_keys)
+      restricted_keys = restricted_keys.map do |key|
+        (key.to_sym rescue key) || key
+      end
+      to_options(options).delete_if do |key, value|
+        !restricted_keys.include?(key)
+      end
+    end
+
+    def wait_connectivity(host, port, max_time)
+      begin
+        Timeout::timeout(max_time) do
+          begin
+            s = TCPSocket.new(host, port)
+            s.close
+            true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            sleep 0.1
+            retry
+          end
+        end
+      rescue Timeout::Error
+        false
+      end
+    end
+  end
+end

data/lib/cukunity.rb

@@ -0,0 +1,19 @@
+# -*- coding: UTF-8 -*-
+
+require 'rubygems'
+require 'json'
+require 'rspec'
+require 'cucumber'
+
+module Cukunity
+end
+
+$:.unshift(File.dirname(__FILE__))
+require 'cukunity/exceptions'
+require 'cukunity/utils'
+require 'cukunity/request_line_response_client_methods'
+require 'cukunity/touch_input_methods'
+require 'cukunity/keyboard_input_methods'
+require 'cukunity/unity'
+require 'cukunity/drivers/android'
+require 'cukunity/drivers/iOS'