map-kit-wrapper 0.0.1

data/.gitignore

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

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Kasper Weibel Nielsen-Refs
+
+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,45 @@
+MapKitWrapper
+=============
+
+This is a MapKit wrapper for RubyMotion. It's purpose is to make make dealing with MapKit less painfull
+
+It is still work in progress, but right now there are wrappers for the Map Kit Data Types and the Core Location Data Types. Those will save you a lot of typing.
+
+## Installation
+```ruby
+gem install map-kit-wrapper
+```
+
+## Setup
+
+Edit the `Rakefile` of your RubyMotion project and add the following require line.
+
+```ruby
+require 'map-kit-wrapper'
+```
+
+## Example
+```ruby
+
+def loadView
+  self.view = UIView.alloc.initWithFrame(tabBarController.view.bounds)
+  map = MapView.new
+  map.frame = self.view.frame
+  map.delegate = self
+  region = CoordinateRegion.new([56, 10.6], [3.1, 3.1])
+  map.region = region
+  # Alternatively use set_region
+  # map.set_region(region, :animated => true)
+  map.showsUserLocation = true
+  self.view.addSubview(map)
+end
+```    
+Check if the users location has been found
+```ruby
+@map.user_located?
+```    
+Get the users coordinates
+```ruby
+@map.user_coordinates
+```    
+

data/Rakefile

@@ -0,0 +1,14 @@
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project'
+require 'bundler/gem_tasks'
+Bundler.setup
+Bundler.require
+require 'bubble-wrap/test'
+
+Motion::Project::App.setup do |app|
+  # Use `rake config' to see complete project settings.
+  app.name = 'MapKitWrapper'
+  app.files =  Dir.glob(File.join(app.project_dir, 'motion/**/*.rb'))
+  app.files_dependencies 'motion/map_view.rb' => 'motion/zoom_level.rb'
+  app.frameworks += ['CoreLocation', 'MapKit']
+end

data/lib/map_kit_wrapper.rb

@@ -0,0 +1 @@
+require 'map_kit_wrapper/version' unless defined?(MapKit::VERSION)

data/lib/map_kit_wrapper/version.rb

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

data/map_kit_wrapper.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/map_kit_wrapper/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Kasper Weibel Nielsen-Refs"]
+  gem.email         = ["weibel@gmail.com"]
+  gem.summary       = %q{This is a MapKit wrapper for RubyMotion. It's 
+purpose is to make make dealing with MapKit less painfull}
+  gem.homepage      = "https://github.com/weibel/MapKitWrapper"
+
+  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.name          = "map-kit-wrapper"
+  gem.require_paths = ["lib"]
+  gem.version       = MapKit::VERSION
+
+  gem.add_dependency 'bubble-wrap'
+  gem.add_development_dependency 'rake'
+end

data/motion/core_location_data_types.rb

@@ -0,0 +1,35 @@
+module CoreLocation
+  # Wrappers for the Core Location Data Types
+  # http://developer.apple.com/library/mac/#documentation/CoreLocation/Reference/CoreLocationDataTypesRef/Reference/reference.html
+  module DataTypes
+
+    # Ruby wrapper for CLLocationCoordinate2D
+    class LocationCoordinate
+      attr_reader :sdk
+
+      # LocationCoordinate.new(1,2)
+      # LocationCoordinate.new([1,2])
+      # CoordinateSpan.new(CLLocationCoordinate2D)
+      def initialize(*args)
+        args.flatten!
+        if args.first.is_a?(CLLocationCoordinate2D)
+          @sdk = args.first
+        else
+          @sdk = CLLocationCoordinate2DMake(args[0], args[1])
+        end
+      end
+
+      def latitude
+        @sdk.latitude
+      end
+
+      def longitude
+        @sdk.longitude
+      end
+
+      def to_array
+        [latitude, longitude]
+      end
+    end
+  end
+end

data/motion/map_kit_data_types.rb

@@ -0,0 +1,162 @@
+module MapKit
+  # Wrappers for the Map Kit Data Types
+  # http://developer.apple.com/library/ios/#documentation/MapKit/Reference/MapKitDataTypesReference/Reference/reference.html
+  module DataTypes
+
+    # Wrapper for MKCoordinateSpan
+    class CoordinateSpan
+      attr_reader :sdk
+
+      # CoordinateSpan.new(1,2)
+      # CoordinateSpan.new([1,2])
+      # CoordinateSpan.new(MKCoordinateSpan)
+      def initialize(*args)
+        args.flatten!
+        if args.first.is_a?(MKCoordinateSpan)
+          @sdk = args.first
+        else
+          @sdk = MKCoordinateSpanMake(args[0], args[1])
+        end
+      end
+
+      def latitude_delta
+        @sdk.latitudeDelta
+      end
+
+      def longitude_delta
+        @sdk.longitudeDelta
+      end
+
+      def to_array
+        [latitude_delta, longitude_delta]
+      end
+    end
+
+    # Wrapper for MKCoordinateRegion
+    class CoordinateRegion
+      include CoreLocation::DataTypes
+      attr_reader :sdk
+
+      # CoordinateRegion.new(CoordinateRegion)
+      # CoordinateRegion.new(MKCoordinateRegion)
+      # CoordinateRegion.new([56, 10.6], [3.1, 3.1])
+      # CoordinateRegion.new(LocationCoordinate, CoordinateSpan)
+      # CoordinateRegion.new(CLLocationCoordinate2D, MKCoordinateSpan)
+      def initialize(*args)
+        if args.size == 1
+          if args[0].is_a?(CoordinateRegion)
+            center, span = args[0].center.sdk, args[0].span.sdk
+          else
+            center, span = args[0].center, args[0].span
+          end
+        else
+          center = args[0].is_a?(LocationCoordinate) ? args[0].sdk : args[0]
+          span = args[1].is_a?(CoordinateSpan) ? args[1].sdk : args[1]
+        end
+        @sdk = MKCoordinateRegionMake(center, span)
+      end
+
+      def center
+        LocationCoordinate.new(@sdk.center)
+      end
+
+      def span
+        CoordinateSpan.new(@sdk.span)
+      end
+
+      def to_hash
+        {:center => center.to_array, :span => span.to_array}
+      end
+    end
+
+    # Wrapper for MKMapPoint
+    class MapPoint
+      attr_reader :sdk
+
+      # MapPoint.new(50,45)
+      # MapPoint.new([50,45])
+      # MapPoint.new(MKMapPoint)
+      def initialize(*args)
+        args.flatten!
+        if args.first.is_a?(MKMapPoint)
+          @sdk = args.first
+        else
+          @sdk = MKMapPointMake(args[0], args[1])
+        end
+      end
+
+      def x
+        @sdk.x
+      end
+
+      def y
+        @sdk.y
+      end
+
+      def to_array
+        [x, y]
+      end
+    end
+
+    # Wrapper for MKMapSize
+    class MapSize
+      attr_reader :sdk
+
+      # MapSize.new(10,12)
+      # MapSize.new([10,12])
+      # MapSize.new(MKMapSize)
+      def initialize(*args)
+        args.flatten!
+        if args.first.is_a?(MKMapSize)
+          @sdk = args.first
+        else
+          @sdk = MKMapSizeMake(args[0], args[1])
+        end
+      end
+
+      def width
+        @sdk.width
+      end
+
+      def height
+        @sdk.height
+      end
+
+      def to_array
+        [width, height]
+      end
+    end
+
+    # Wrapper for MKMapRect
+    class MapRect
+      attr_reader :sdk
+
+      # MapRect.new(x, y, width, height)
+      # MapRect.new([x, y], [width, height])
+      # MapRect.new(MapPoint, MapSize)
+      # MapRect.new(MKMapPoint, MKMapSize)
+      def initialize(*args)
+        args.flatten!
+        if args.size == 2
+          origin = args[0].is_a?(MapPoint) ? args[0] : MapPoint.new(args[0])
+          size = args[1].is_a?(MapSize) ? args[1] : MapSize.new(args[1])
+          @sdk = MKMapRectMake(origin.sdk.x, origin.sdk.y, size.sdk.width, size.sdk.height)
+        elsif args.size == 4
+          @sdk = MKMapRectMake(args[0], args[1], args[2], args[3])
+        end
+      end
+
+      def origin
+        MapPoint.new(@sdk.origin)
+      end
+
+      def size
+        MapSize.new(@sdk.size)
+      end
+
+      def to_hash
+        {:origin => origin.to_array, :size => size.to_array}
+      end
+    end
+  end
+end

data/motion/map_type.rb

@@ -0,0 +1,25 @@
+module MapKit
+  class MapType
+    def self.mkmap_to_rmap(map_type)
+      case map_type
+        when MKMapTypeStandard
+          :standard
+        when MKMapTypeSatellite
+          :satellite
+        when MKMapTypeHybrid
+          :hybrid
+      end
+    end
+
+    def self.rmap_to_mkmap(map_type)
+      case map_type
+        when :standard
+          MKMapTypeStandard
+        when :satellite
+          MKMapTypeSatellite
+        when :hybrid
+          MKMapTypeHybrid
+      end
+    end
+  end
+end

data/motion/map_view.rb

@@ -0,0 +1,69 @@
+module MapKit
+  include CoreLocation::DataTypes
+  include MapKit::DataTypes
+
+  # Wrapper for MKMapView
+  class MapView < MKMapView
+    include CoreLocation::DataTypes
+    include MapKit::DataTypes
+    include MapKit::ZoomLevel
+
+    def initialize
+      self.alloc.init
+    end
+
+    # zoom methods
+
+    def zoom_enabled?
+      self.isZoomEnabled
+    end
+
+    def zoom_enabled=(enabled)
+      self.setZoomEnabled(enabled)
+    end
+
+    # scroll methods
+
+    def scroll_enabled?
+      self.isScrollEnabled
+    end
+
+    def scroll_enabled=(enabled)
+      self.setScrollEnabled(enabled)
+    end
+
+    # user location methods
+
+    def shows_user_location?
+      self.showsUserLocation
+    end
+
+    def shows_user_location=(enabled)
+      self.showsUserLocation = enabled
+    end
+
+    def user_located?
+      self.shows_user_location? && self.userLocation.location ? true : false
+    end
+
+    def user_coordinates
+      self.user_located? ? LocationCoordinate.new(self.userLocation.location.coordinate) : nil
+    end
+
+    # region methods
+
+    def get_region
+      CoordinateRegion.new(self.region.center, self.region.span)
+    end
+
+    def region=(*args)
+      self.set_region(CoordinateRegion.new(args.first), false)
+    end
+
+    def set_region(coordinate_region, *args)
+      opts = {:animated => false}
+      opts.merge!(args.first) if args.first
+      self.setRegion(coordinate_region.sdk, animated:opts[:animated])
+    end
+  end
+end

data/motion/test_suite_delegate.rb

@@ -0,0 +1,9 @@
+class TestSuiteDelegate
+  attr_accessor :window
+
+  def application(application, didFinishLaunchingWithOptions: launchOptions)
+    @window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+    @window.rootViewController = UIViewController.alloc.init
+    true
+  end
+end

data/motion/zoom_level.rb

@@ -0,0 +1,162 @@
+module MapKit
+  # Ruby conversion of http://troybrant.net/blog/2010/01/set-the-zoom-level-of-an-mkmapview/
+  module ZoomLevel
+    include Math
+    MERCATOR_OFFSET = 268435456.0
+    MERCATOR_RADIUS = 85445659.44705395
+
+    module ClassMethods
+      include Math
+      # Map conversion methods
+
+      def longitude_to_pixel_space_x(longitude)
+        (MERCATOR_OFFSET + MERCATOR_RADIUS * longitude * PI / 180.0).round
+      end
+
+      def latitude_to_pixel_space_y(latitude)
+        if latitude == 90.0
+          0
+        elsif latitude == -90.0
+          MERCATOR_OFFSET * 2
+        else
+          (MERCATOR_OFFSET - MERCATOR_RADIUS * log((1 + sin(latitude * PI / 180.0)) / (1 - sin(latitude * PI / 180.0))) / 2.0).round
+        end
+      end
+
+      def pixel_space_x_to_longitude(pixel_x)
+        ((pixel_x.round - MERCATOR_OFFSET) / MERCATOR_RADIUS) * 180.0 / PI
+      end
+
+      def pixel_space_y_to_latitude(pixel_y)
+        (PI / 2.0 - 2.0 * atan(exp((pixel_y.round - MERCATOR_OFFSET) / MERCATOR_RADIUS))) * 180.0 / PI
+      end
+
+      def coordinate_span_with_map_view(map_view, center_coordinate, zoom_level)
+        # convert center coordiate to pixel space
+        center_pixel_x = self.longitude_to_pixel_space_x(center_coordinate.longitude)
+        center_pixel_y = self.latitude_to_pixel_space_y(center_coordinate.latitude)
+
+        # determine the scale value from the zoom level
+        zoom_exponent = 20 - zoom_level
+        zoom_scale = 2 ** zoom_exponent
+
+        # scale the map’s size in pixel space
+        map_size_in_pixels = map_view.bounds.size
+        scaled_map_width = map_size_in_pixels.width * zoom_scale
+        scaled_map_height = map_size_in_pixels.height * zoom_scale
+
+        # figure out the position of the top-left pixel
+        top_left_pixel_x = center_pixel_x - (scaled_map_width / 2)
+        top_left_pixel_y = center_pixel_y - (scaled_map_height / 2)
+
+        # find delta between left and right longitudes
+        min_lng = self.pixel_space_x_to_longitude(top_left_pixel_x)
+        max_lng = self.pixel_space_x_to_longitude(top_left_pixel_x + scaled_map_width)
+        longitude_delta = max_lng - min_lng
+
+        # find delta between top and bottom latitudes
+        min_lat = self.pixel_space_y_to_latitude(top_left_pixel_y)
+        max_lat = self.pixel_space_y_to_latitude(top_left_pixel_y + scaled_map_height)
+        latitude_delta = -1 * (max_lat - min_lat)
+
+        # create and return the lat/lng span
+        MKCoordinateSpanMake(latitude_delta, longitude_delta)
+      end
+
+      # KMapView cannot display tiles that cross the pole
+      # This would involve wrapping the map from top to bottom, something that a Mercator projection just cannot do.
+      def coordinate_region_with_map_view(map_view, center_coordinate, zoom_level)
+
+        # clamp lat/long values to appropriate ranges
+        center_coordinate.latitude = [[-90.0, center_coordinate.latitude].max, 90.0].min
+        center_coordinate.longitude = center_coordinate.longitude % 180.0
+
+        # convert center coordiate to pixel space
+        center_pixel_x = self.longitude_to_pixel_space_x(center_coordinate.longitude)
+        center_pixel_y = self.latitude_to_pixel_space_y(center_coordinate.latitude)
+
+        # determine the scale value from the zoom level
+        zoom_exponent = 20 - zoom_level
+        zoom_scale = 2 ** zoom_exponent
+
+        # scale the map’s size in pixel space
+        map_size_in_pixels = map_view.bounds.size
+        scaled_map_width = map_size_in_pixels.width * zoom_scale
+        scaled_map_height = map_size_in_pixels.height * zoom_scale
+
+        # figure out the position of the left pixel
+        top_left_pixel_x = center_pixel_x - (scaled_map_width / 2)
+
+        # find delta between left and right longitudes
+        min_lng = self.pixel_space_x_to_longitude(top_left_pixel_x)
+        max_lng = self.pixel_space_x_to_longitude(top_left_pixel_x + scaled_map_width)
+        longitude_delta = max_lng - min_lng
+
+        # if we’re at a pole then calculate the distance from the pole towards the equator
+        # as MKMapView doesn’t like drawing boxes over the poles
+        top_pixel_y = center_pixel_y - (scaled_map_height / 2)
+        bottom_pixel_y = center_pixel_y + (scaled_map_height / 2)
+        adjusted_center_point = false
+        if top_pixel_y > MERCATOR_OFFSET * 2
+          top_pixel_y = center_pixel_y - scaled_map_height
+          bottom_pixel_y = MERCATOR_OFFSET * 2
+          adjusted_center_point = true
+        end
+
+        # find delta between top and bottom latitudes
+        min_lat = self.pixel_space_y_to_latitude(top_pixel_y)
+        max_lat = self.pixel_space_y_to_latitude(bottom_pixel_y)
+        latitude_delta = -1 * (max_lat - min_lat)
+
+        # create and return the lat/lng span
+        span = MKCoordinateSpanMake(latitude_delta, longitude_delta)
+        region = MKCoordinateRegionMake(center_coordinate, span)
+        # once again, MKMapView doesn’t like drawing boxes over the poles
+        # so adjust the center coordinate to the center of the resulting region
+        if adjusted_center_point
+          region.center.latitude = self.pixel_space_y_to_latitude((bottom_pixel_y + top_pixel_y) / 2.0)
+        end
+
+        region
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Public methods
+
+    def set_center_coordinates(center_coordinate, zoom_level, animated)
+      # clamp large numbers to 28
+      zoom_level = [zoom_level, 28].min
+
+      # use the zoom level to compute the region
+      span = self.class.coordinate_span_with_map_view(self, center_coordinate, zoom_level)
+      region = MKCoordinateRegionMake(center_coordinate, span)
+
+      # set the region like normal
+      self.setRegion(region, animated: animated)
+    end
+
+    def set_map_lat_lon(latitude, longitude, zoom_level, animated)
+      coordinates = CLLocationCoordinate2DMake(latitude, longitude)
+      self.set_center_coordinates(coordinates, zoom_level, animated)
+    end
+
+    def zoom_level
+      region = self.region
+
+      center_pixel_x = self.class.longitude_to_pixel_space_x(region.center.longitude)
+      top_left_pixel_x = self.class.longitude_to_pixel_space_x(region.center.longitude - region.span.longitudeDelta / 2)
+
+      scaled_map_width = (center_pixel_x - top_left_pixel_x) * 2
+      map_size_in_pixels = self.bounds.size
+      zoom_scale = scaled_map_width / map_size_in_pixels.width
+      zoom_exponent = log(zoom_scale) / log(2)
+      zoom_level = 20 - zoom_exponent
+      zoom_level
+    end
+
+  end
+end

data/spec/core_location_data_types_spec.rb

@@ -0,0 +1,32 @@
+describe 'LocationCoordinate' do
+  before do
+    lc_1 = CoreLocation::DataTypes::LocationCoordinate.new(5, 8)
+    lc_2 = CoreLocation::DataTypes::LocationCoordinate.new([5, 8])
+    lc_3 = CoreLocation::DataTypes::LocationCoordinate.new(CLLocationCoordinate2DMake(5, 8))
+    @array = [lc_1, lc_2, lc_3]
+  end
+
+  it 'should return the latitude' do
+    @array.each do |lc|
+      lc.latitude.should.equal 5
+    end
+  end
+
+  it 'should return the longitude' do
+    @array.each do |lc|
+      lc.longitude.should.equal 8
+    end
+  end
+
+  it 'should return an array' do
+    @array.each do |lc|
+      lc.to_array.should.equal [5, 8]
+    end
+  end
+
+  it 'should contain a CLLocationCoordinate2D' do
+    @array.each do |lc|
+      lc.sdk.is_a?(CLLocationCoordinate2D).should.equal true
+    end
+  end
+end

data/spec/map_kit_data_types_spec.rb

@@ -0,0 +1,182 @@
+describe 'MapKitDataTypes' do
+  describe 'CoordinateSpan' do
+    before do
+      o_1 = MapKit::DataTypes::CoordinateSpan.new(5, 8)
+      o_2 = MapKit::DataTypes::CoordinateSpan.new([5, 8])
+      o_3 = MapKit::DataTypes::CoordinateSpan.new(MKCoordinateSpanMake(5, 8))
+      @array = [o_1, o_2, o_3]
+    end
+
+    it 'should return the latitude delta' do
+      @array.each do |o|
+        o.latitude_delta.should.equal 5
+      end
+    end
+
+    it 'should return the longitude delta' do
+      @array.each do |o|
+        o.longitude_delta.should.equal 8
+      end
+    end
+
+    it 'should return an array' do
+      @array.each do |o|
+        o.to_array.should.equal [5, 8]
+      end
+    end
+
+    it 'should contain a MKCoordinateSpan' do
+      @array.each do |o|
+        o.sdk.is_a?(MKCoordinateSpan).should.equal true
+      end
+    end
+  end
+
+  describe 'CoordinateRegion' do
+    before do
+      lc = CoreLocation::DataTypes::LocationCoordinate.new(5, 8)
+      cs = MapKit::DataTypes::CoordinateSpan.new(6, 9)
+      mkcr = MKCoordinateRegionMake(CLLocationCoordinate2DMake(5, 8), MKCoordinateSpanMake(6, 9))
+      o_1 = MapKit::DataTypes::CoordinateRegion.new([5, 8], [6, 9])
+      o_2 = MapKit::DataTypes::CoordinateRegion.new(lc, cs)
+      o_3 = MapKit::DataTypes::CoordinateRegion.new(CLLocationCoordinate2DMake(5, 8), MKCoordinateSpanMake(6, 9))
+      o_4 = MapKit::DataTypes::CoordinateRegion.new(mkcr)
+      o_5 = MapKit::DataTypes::CoordinateRegion.new(o_1)
+      @array = [o_1, o_2, o_3, o_4, o_5]
+    end
+
+    it 'should return the center' do
+      @array.each do |o|
+        o.center.is_a?(CoreLocation::DataTypes::LocationCoordinate).should.equal true
+        o.center.latitude.should.equal 5
+        o.center.longitude.should.equal 8
+      end
+    end
+
+    it 'should return the span' do
+      @array.each do |o|
+        o.span.is_a?(MapKit::DataTypes::CoordinateSpan).should.equal true
+        o.span.latitude_delta.should.equal 6
+        o.span.longitude_delta.should.equal 9
+      end
+    end
+
+    it 'should return a hash' do
+      @array.each do |o|
+        o.to_hash.should.equal({:center => [5, 8], :span => [6, 9]})
+      end
+    end
+
+    it 'should contain a MKCoordinateRegion' do
+      @array.each do |o|
+        o.sdk.is_a?(MKCoordinateRegion).should.equal true
+      end
+    end
+  end
+
+  describe 'MapPoint' do
+    before do
+      o_1 = MapKit::DataTypes::MapPoint.new(5, 8)
+      o_2 = MapKit::DataTypes::MapPoint.new([5, 8])
+      o_3 = MapKit::DataTypes::MapPoint.new(MKMapPointMake(5, 8))
+      @array = [o_1, o_2, o_3]
+    end
+
+    it 'should return the x' do
+      @array.each do |o|
+        o.x.should.equal 5
+      end
+    end
+
+    it 'should return the y' do
+      @array.each do |o|
+        o.y.should.equal 8
+      end
+    end
+
+    it 'should return an array' do
+      @array.each do |o|
+        o.to_array.should.equal [5, 8]
+      end
+    end
+
+    it 'should contain a MKMapPoint' do
+      @array.each do |o|
+        o.sdk.is_a?(MKMapPoint).should.equal true
+      end
+    end
+  end
+
+  describe 'MapSize' do
+    before do
+      o_1 = MapKit::DataTypes::MapSize.new(5, 8)
+      o_2 = MapKit::DataTypes::MapSize.new([5, 8])
+      o_3 = MapKit::DataTypes::MapSize.new(MKMapSizeMake(5, 8))
+      @array = [o_1, o_2, o_3]
+    end
+
+    it 'should return the width' do
+      @array.each do |o|
+        o.width.should.equal 5
+      end
+    end
+
+    it 'should return the height' do
+      @array.each do |o|
+        o.height.should.equal 8
+      end
+    end
+
+    it 'should return an array' do
+      @array.each do |o|
+        o.to_array.should.equal [5, 8]
+      end
+    end
+
+    it 'should contain a MKMapSize' do
+      @array.each do |o|
+        o.sdk.is_a?(MKMapSize).should.equal true
+      end
+    end
+  end
+
+  describe 'MapRect' do
+    before do
+      mp = MapKit::DataTypes::MapPoint.new(5, 8)
+      ms = MapKit::DataTypes::MapSize.new(6, 9)
+      o_1 = MapKit::DataTypes::MapRect.new(5, 8, 6, 9)
+      o_2 = MapKit::DataTypes::MapRect.new([5, 8], [6, 9])
+      o_3 = MapKit::DataTypes::MapRect.new(mp, ms)
+      o_4 = MapKit::DataTypes::MapRect.new(MKMapPointMake(5, 8), MKMapSizeMake(6, 9))
+      @array = [o_1, o_2, o_3, o_4]
+    end
+
+    it 'should return the origin' do
+      @array.each do |o|
+        o.origin.is_a?(MapKit::DataTypes::MapPoint).should.equal true
+        o.origin.x.should.equal 5
+        o.origin.y.should.equal 8
+      end
+    end
+
+    it 'should return the size' do
+      @array.each do |o|
+        o.size.is_a?(MapKit::DataTypes::MapSize).should.equal true
+        o.size.width.should.equal 6
+        o.size.height.should.equal 9
+      end
+    end
+
+    it 'should return a hash' do
+      @array.each do |o|
+        o.to_hash.should.equal({:origin => [5, 8], :size => [6, 9]})
+      end
+    end
+
+    it 'should contain a MKMapRect' do
+      @array.each do |o|
+        o.sdk.is_a?(MKMapRect).should.equal true
+      end
+    end
+  end
+end

data/spec/map_view_spec.rb

@@ -0,0 +1,80 @@
+describe 'MapView' do
+  before do
+    @map = MapKit::MapView.new
+    @map.delegate = self
+    @map.frame = UIScreen.mainScreen.bounds
+    @map.region = MapKit::CoordinateRegion.new([56, 10.6], [3.1, 3.1])
+    @map.zoom_enabled = false
+    @map.scroll_enabled = false
+  end
+
+  it 'should initialize' do
+    @map.should.satisfy { |object| object.is_a? MapKit::MapView }
+  end
+
+  # zoom
+
+  it 'should show zoom_enabled?' do
+    @map.zoom_enabled?.should.equal false
+  end
+
+  it 'should set zoom_enabled' do
+    @map.zoom_enabled = true
+    @map.zoom_enabled?.should.equal true
+  end
+
+  # scroll
+
+  it 'should show scroll_enabled?' do
+    @map.scroll_enabled?.should.equal false
+  end
+
+  it 'should show zoom_enabled' do
+    @map.scroll_enabled = true
+    @map.scroll_enabled?.should.equal true
+  end
+
+  # user location
+
+  it 'should show shows_user_location?' do
+    @map.shows_user_location?.should.equal false
+  end
+
+  it 'should set shows_user_location' do
+    @map.shows_user_location = true
+    @map.shows_user_location?.should == true
+  end
+
+  it 'should show user_located?' do
+    @map.user_located?.should.equal false
+    @map.shows_user_location = true
+    #wait 10 do
+    #  @map.user_located?.should.equal true
+    #end
+  end
+
+  it 'should show user_coordinates' do
+    @map.user_coordinates.should.equal nil
+    @map.shows_user_location = true
+    #wait 10 do
+    #  @map.user_coordinates.latitude.should.equal 56
+    #end
+  end
+
+  # region
+
+  it 'should show get_region' do
+    @map.get_region.should.satisfy { |object| object.is_a? MapKit::DataTypes::CoordinateRegion }
+  end
+
+  it 'should set region=' do
+    @map.region = MapKit::CoordinateRegion.new([56, 10.6], [3.1, 3.1])
+    @map.get_region.should.satisfy { |object| object.is_a? MapKit::DataTypes::CoordinateRegion }
+  end
+
+  it 'should set_region(coordinate_region, *args)' do
+    @map.set_region(MapKit::CoordinateRegion.new([56, 10.6], [3.1, 3.1]), false)
+    @map.get_region.should.satisfy { |object| object.is_a? MapKit::DataTypes::CoordinateRegion }
+  end
+
+end

data/spec/zoom_level_spec.rb

@@ -0,0 +1,71 @@
+describe 'ZoomLevel' do
+  before do
+    @map = MapKit::MapView.new
+    @map.delegate = self
+    @map.frame = UIScreen.mainScreen.bounds
+    @map.region = MapKit::CoordinateRegion.new([56, 10.6], [3.1, 3.1])
+  end
+
+  it 'should return longitude_to_pixel_space_x' do
+    MapKit::MapView.longitude_to_pixel_space_x(30).should.equal 313174656
+  end
+
+  it 'should return latitude_to_pixel_space_y' do
+    MapKit::MapView.latitude_to_pixel_space_y(90).should.equal 0
+    MapKit::MapView.latitude_to_pixel_space_y(-90).should.equal 536870912
+    MapKit::MapView.latitude_to_pixel_space_y(0).should.equal 268435456
+  end
+
+  it 'should return pixel_space_x_to_longitude' do
+    MapKit::MapView.pixel_space_x_to_longitude(313174656).should.equal 29.999984741210 # 30
+  end
+
+  it 'should return pixel_space_y_to_latitude' do
+    MapKit::MapView.pixel_space_y_to_latitude(0).should.equal 85.0511169433594 # 90
+    MapKit::MapView.pixel_space_y_to_latitude(536870912).should.equal -85.0511169433594 # -90
+    MapKit::MapView.pixel_space_y_to_latitude(268435456).should.equal 0
+  end
+
+  it 'should return coordinate_span_with_map_view' do
+    span = MapKit::MapView.coordinate_span_with_map_view(@map, CLLocationCoordinate2DMake(56, 10), 2)
+    span.latitudeDelta.should.equal 48.452224731445
+    span.longitudeDelta.should.equal 56.25
+  end
+
+  it 'should return set_center_coordinates' do
+    @map.set_center_coordinates(CLLocationCoordinate2DMake(56, 10), 2, false)
+    center = CoreLocation::DataTypes::LocationCoordinate.new(@map.region.center)
+    span = MapKit::DataTypes::CoordinateSpan.new(@map.region.span)
+    span.latitude_delta.should.equal 48.4812927246094
+    span.longitude_delta.should.equal 56.25
+    center.latitude.should.equal 55.9737854003906
+    center.longitude.should.equal 10.01953125
+  end
+
+  it 'should return set_map_lat_lon' do
+    @map.set_map_lat_lon(56, 10, 2, false)
+    center = CoreLocation::DataTypes::LocationCoordinate.new(@map.region.center)
+    span = MapKit::DataTypes::CoordinateSpan.new(@map.region.span)
+    span.latitude_delta.should.equal 48.4812927246094
+    span.longitude_delta.should.equal 56.25
+    center.latitude.should.equal 55.9737854003906
+    center.longitude.should.equal 10.01953125
+  end
+
+  it 'should return coordinate_region_with_map_view' do
+    view = MKMapView.alloc.init
+    view.frame = @map.frame
+    center = CLLocationCoordinate2DMake(56, 10)
+    region = MapKit::MapView.coordinate_region_with_map_view(view, center, 2)
+    center = CoreLocation::DataTypes::LocationCoordinate.new(region.center)
+    span = MapKit::DataTypes::CoordinateSpan.new(region.span)
+    span.latitude_delta.should.equal 48.4522247314453
+    span.longitude_delta.should.equal 56.25
+    center.latitude.should.equal 56.0
+    center.longitude.should.equal 10.0
+  end
+
+  it 'should have a zoom_level' do
+    @map.zoom_level.should.equal 5.00000381469727
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: map-kit-wrapper
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Kasper Weibel Nielsen-Refs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bubble-wrap
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  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
+description: 
+email: 
+- weibel@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/map_kit_wrapper.rb
+- lib/map_kit_wrapper/version.rb
+- map_kit_wrapper.gemspec
+- motion/core_location_data_types.rb
+- motion/map_kit_data_types.rb
+- motion/map_type.rb
+- motion/map_view.rb
+- motion/test_suite_delegate.rb
+- motion/zoom_level.rb
+- spec/core_location_data_types_spec.rb
+- spec/map_kit_data_types_spec.rb
+- spec/map_view_spec.rb
+- spec/zoom_level_spec.rb
+homepage: https://github.com/weibel/MapKitWrapper
+licenses: []
+
+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: This is a MapKit wrapper for RubyMotion. It's  purpose is to make make dealing with MapKit less painfull
+test_files: 
+- spec/core_location_data_types_spec.rb
+- spec/map_kit_data_types_spec.rb
+- spec/map_view_spec.rb
+- spec/zoom_level_spec.rb