ProMotion-amap 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3d553efc4a20071ec4a296503fc1aea40cadcc3c
+  data.tar.gz: 4264934552eed6acc9d861bf12b57083c9355621
+SHA512:
+  metadata.gz: 742d5731c72d41e998a6993d1d4ce83964dc87aac7d571aaecb404cdcd9a5afd7ffe5a02c6458ac0c5cd9810b4129c715c9b01e24f3e0e1b3466f002fdccb07b
+  data.tar.gz: 6e528ce3640347edbe261cbbf119d175c9d7e7efa6a09ffca6b6931929ba903eba4a8e814d85e4842954ddf221602372bdd906e52f3cf0290936b947160c8f5a

data/README.md

@@ -0,0 +1,269 @@
+# ProMotion-amap
+
+[![Gem Version](https://badge.fury.io/rb/ProMotion-map.svg)](http://badge.fury.io/rb/ProMotion-map) [![Build Status](https://travis-ci.org/clearsightstudio/ProMotion-map.svg)](https://travis-ci.org/clearsightstudio/ProMotion-map) [![Code Climate](https://codeclimate.com/github/clearsightstudio/ProMotion-map.png)](https://codeclimate.com/github/clearsightstudio/ProMotion-map)
+
+ProMotion-map provides a PM::MapScreen, extracted from the
+popular RubyMotion gem [ProMotion](https://github.com/clearsightstudio/ProMotion).
+AMap link: http://lbs.amap.com/api/ios-sdk/summary/
+
+## Installation
+
+```ruby
+gem 'ProMotion-map'
+```
+
+## Usage
+
+Easily create a map screen, complete with annotations.
+
+*Has all the methods of PM::Screen*
+
+```ruby
+class MyMapScreen < PM::MapScreen
+  title "My Map"
+  start_position latitude: 35.090648651123, longitude: -82.965972900391, radius: 4
+
+  def annotation_data
+    [{
+      longitude: -82.965972900391,
+      latitude: 35.090648651123,
+      title: "Rainbow Falls",
+      subtitle: "Nantahala National Forest",
+      action: :show_forest
+    },{
+      longitude: -82.966093558105,
+      latitude: 35.092520895652,
+      title: "Turtleback Falls",
+      subtitle: "Nantahala National Forest",
+      action: :show_forest
+    },{
+      longitude: -82.95916,
+      latitude: 35.07496,
+      title: "Windy Falls",
+      action: :show_forest
+    },{
+      longitude: -82.943031505056,
+      latitude: 35.102516828489,
+      title: "Upper Bearwallow Falls",
+      subtitle: "Gorges State Park",
+      action: :show_forest
+    },{
+      longitude: -82.956244328014,
+      latitude: 35.085548421623,
+      title: "Stairway Falls",
+      subtitle: "Gorges State Park",
+      your_param: "CustomWhatever",
+      action: :show_forest
+    }, {
+      longitude: -82.965972900391,
+      latitude: 35.090648651123,
+      title: "Rainbow Falls",
+      subtitle: "Nantahala National Forest",
+      image: UIImage.imageNamed("custom-pin"),
+      action: :show_forest
+    }]
+  end
+
+  def show_forest
+    selected = selected_annotations.first
+    # Do something with the selected annotation.
+  end
+end
+```
+
+Here's a neat way to zoom into a specific marker in an animated fashion and then select the marker:
+
+```ruby
+def zoom_to_marker(marker)
+  set_region region(coordinate: marker.coordinate, span: [0.05, 0.05])
+  select_annotation marker
+end
+```
+
+---
+
+### Methods
+
+#### annotation_data
+
+Method that is called to get the map's annotation data and build the map. If you do not want any annotations, simply return an empty array.
+
+All possible properties:
+
+```ruby
+{
+    longitude: -82.956244328014, # REQUIRED
+    latitude: 35.085548421623, # REQUIRED
+    title: "Stairway Falls", # REQUIRED
+    subtitle: "Gorges State Park",
+    image: "my_custom_image",
+    left_accessory: my_button,
+    right_accessory: my_other_button,
+    action: :my_action, # Overrides :right_accessory
+    action_button_type: UIButtonTypeContactAdd # Defaults to UIButtonTypeDetailDisclosure
+}
+```
+
+You may pass whatever properties you want in the annotation hash, but `:longitude`, `:latitude`, and `:title` are required.
+
+Use `:image` to specify a custom image. Pass in a string to conserve memory and it will be converted using `UIImage.imageNamed(your_string)`. If you pass in a `UIImage`, we'll use that, but keep in mind that there will be another unnecessary copy of the UIImage in memory.
+
+Use `:left_accessory` and `:right_accessory` to specify a custom accessory, like a button.
+
+You can access annotation data you've arbitrarily stored in the hash by calling `annotation_instance.params[:your_param]`.
+
+The `:action` parameter specifies a method that should be run when the detail button is tapped on the annotation. It automatically adds a `UIButtonTypeDetailDisclosure` button to the `:left_accessory`. In your method you can find out which annotation's accessory was tapped by calling `selected_annotations.first`.
+
+#### update_annotation_data
+
+Forces a reload of all the annotations
+
+#### annotations
+
+Returns an array of all the annotations.
+
+#### center
+
+Returns a `CLLocation2D` instance with the center coordinates of the map.
+
+#### center=({latitude: Float, longitude: Float, animated: Boolean})
+
+Sets the center of the map. `animated` property defaults to `true`.
+
+#### show_user_location
+
+Shows the user's location on the map.
+
+##### iOS 8 Location Requirements
+
+iOS 8 introduced stricter location services requirements. You are now required to add a few key/value pairs to the `Info.plist`. Add these two lines to your `Rakefile` (with your descriptions, obviously):
+
+```ruby
+app.info_plist['NSLocationAlwaysUsageDescription'] = 'Description'
+app.info_plist['NSLocationWhenInUseUsageDescription'] = 'Description'
+```
+
+*Note: you need both keys to use `get_once`, so it's probably best to just include both no matter what.* See [Apple's documentation](https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW18) on iOS 8 location services requirements for more information.
+
+#### hide_user_location
+
+Hides the user's location on the map.
+
+#### showing_user_location?
+
+Returns a `Boolean` of whether or not the map view is currently showing the user's location.
+
+#### user_location
+
+Returns a `CLLocation2D` object of the user's location or `nil` if the user location is not being tracked
+
+#### zoom_to_user(radius = 0.05, animated=true)
+
+Zooms to the user's location. If the user's location is not currently being shown on the map, it will show it first. `radius` is a `CLLocationDegrees` of the latitude and longitude deltas. _See Apple documentation for `MKCoordinateSpan` for more information._
+
+#### select_annotation(annotation, animated=true)
+
+Selects a single annotation.
+
+#### select_annotation_at(annotation_index, animated=true)
+
+Selects a single annotation using the annotation at the index of your `annotation_data` array.
+
+#### selected_annotations
+
+Returns an array of annotations that are selected. If no annotations are selected, returns `nil`.
+
+#### deselect_annotations(animated=false)
+
+Deselects all selected annotations.
+
+#### add_annotation(annotation)
+
+Adds a new annotation to the map. Refer to `annotation_data` (above) for hash properties.
+
+#### add_annotations(annotations)
+
+Adds more than one annotation at a time to the map.
+
+#### clear_annotations
+
+Removes all annotations from the `MapScreen`.
+
+#### zoom_to_fit_annotations({animated:true, include_user:false})
+
+Changes the zoom and center point of the `MapScreen` to fit all the annotations. Passing `include_user` as `true` will cause the zoom to not only include the annotations from `annotation_data` but also the user pin in the zoom region calculation.
+
+#### set_region(region, animated=true)
+
+Sets the region of the `MapScreen`. `region` should be an instance of `MKCoordinateRegion`.
+
+#### region(params)
+
+Helper method to create an `MKCoordinateRegion`. Expects a hash in the form of:
+
+```ruby
+my_region = region({
+  coordinate:{
+    latitude: 35.0906,
+    longitude: -82.965
+  },
+  # span is the latitude and longitude delta
+  span: [0.5, 0.5]
+})
+```
+
+---
+
+### Class Methods
+
+#### start_position(latitude: Float, longitude: Float, radius: Float)
+
+Class method to set the initial starting position of the `MapScreen`.
+
+```ruby
+class MyMapScreen < PM::MapScreen
+  start_position latitude: 36.10, longitude: -80.26, radius: 4
+end
+```
+
+`radius` is the zoom level of the map in miles (default: 10).
+
+---
+
+### CocoaTouch Property Convenience Methods
+
+`MKMapView` contains multiple property setters and getters that can be accessed in a more ruby-like syntax:
+
+```ruby
+type # Returns a MKMapType
+type = (MKMapType)new_type
+
+zoom_enabled?
+zoom_enabled = (bool)enabled
+
+scroll_enabled?
+scroll_enabled = (bool)enabled
+
+pitch_enabled?
+pitch_enabled = (bool)enabled
+
+rotate_enabled?
+rotate_enabled = (bool)enabled
+```
+
+---
+
+### Accessors
+
+#### `map` or `mapview`
+
+Reference to the created UIMapView.
+
+## 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. Make some specs pass
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/lib/ProMotion-map.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+require 'motion-cocoapods'
+unless defined?(Motion::Project::Config)
+  raise "ProMotion-map must be required within a RubyMotion project."
+end
+
+Motion::Project::App.setup do |app|
+  lib_dir_path = File.dirname(File.expand_path(__FILE__))
+  app.files << File.join(lib_dir_path, "ProMotion/map/map_screen_annotation.rb")
+  app.files << File.join(lib_dir_path, "ProMotion/map/map_screen_module.rb")
+  app.files << File.join(lib_dir_path, "ProMotion/map/map_screen.rb")
+
+  app.frameworks += %w(CoreLocation MapKit)
+
+  app.pods do
+    pod 'AMap2DMap', '~> 2.4.2'
+  end
+end

data/lib/ProMotion/map/map_screen.rb

@@ -0,0 +1,6 @@
+module ProMotion
+  class MapScreen < ViewController
+    include ProMotion::ScreenModule
+    include ProMotion::MapScreenModule
+  end
+end

data/lib/ProMotion/map/map_screen_annotation.rb

@@ -0,0 +1,67 @@
+module ProMotion
+  class MapScreenAnnotation
+    attr_reader :params
+
+    # Creates the new annotation object
+    def initialize(params = {})
+      @params = params
+      set_defaults
+
+      unless @params[:latitude] && @params[:longitude]
+        PM.logger.error("You are required to specify :latitude and :longitude for annotations.")
+        return nil
+      end
+      @coordinate = CLLocationCoordinate2D.new(@params[:latitude], @params[:longitude])
+    end
+
+    def set_defaults
+      @params = {
+        title: "Title",
+        pin_color: MAPinAnnotationColorRed,
+        identifier: "Annotation-#{@params[:pin_color]}-#{@params[:image]}",
+        show_callout: true,
+        animates_drop: false
+      }.merge(@params)
+    end
+
+    def title
+      @params[:title]
+    end
+
+    def subtitle
+      @params[:subtitle] ||= nil
+    end
+
+    def coordinate
+      @coordinate
+    end
+
+    def cllocation
+      CLLocation.alloc.initWithLatitude(@params[:latitude], longitude:@params[:longitude])
+    end
+
+    def setCoordinate(new_coordinate);
+      if new_coordinate.is_a? Hash
+        @coordinate = CLLocationCoordinate2D.new(new_coordinate[:latitude], new_coordinate[:longitude])
+      else
+        @coordinate = new_coordinate
+      end
+    end
+
+    def method_missing(meth, *args)
+      if @params[meth.to_sym]
+        @params[meth.to_sym]
+      else
+        PM.logger.warn "The annotation parameter \"#{meth}\" does not exist on this pin."
+        nil
+      end
+    end
+
+    # Deprecated
+    def annotation_params
+      PM.logger.warn("annotation.annotation_params is deprecated and will be removed soon. Please use annotation.params instead.")
+      @params
+    end
+
+  end
+end

data/lib/ProMotion/map/map_screen_module.rb

@@ -0,0 +1,308 @@
+module ProMotion
+  module MapScreenModule
+
+    def screen_setup
+      self.view = nil
+      NSLog NSBundle.mainBundle.bundleIdentifier
+      MAMapServices.sharedServices.apiKey = "d479b065447f24f12381a58a1aa41f00"
+      self.view = MAMapView.alloc.initWithFrame(self.view.bounds)
+      self.view.delegate = self
+
+      check_annotation_data
+      @promotion_annotation_data = []
+      set_up_start_position
+    end
+
+    def view_will_appear(animated)
+      super
+      update_annotation_data
+    end
+
+    def check_annotation_data
+      PM.logger.error "Missing #annotation_data method in MapScreen #{self.class.to_s}." unless self.respond_to?(:annotation_data)
+    end
+
+    def update_annotation_data
+      clear_annotations
+      add_annotations annotation_data
+    end
+
+    def map
+      self.view
+    end
+    alias_method :mapview, :map
+
+    def center
+      self.view.centerCoordinate
+    end
+
+    def center=(params={})
+      PM.logger.error "Missing #:latitude property in call to #center=." unless params[:latitude]
+      PM.logger.error "Missing #:longitude property in call to #center=." unless params[:longitude]
+      params[:animated] ||= true
+
+      # Set the new region
+      self.view.setCenterCoordinate(
+        CLLocationCoordinate2D.new(params[:latitude], params[:longitude]),
+        animated:params[:animated]
+      )
+    end
+
+    def show_user_location
+      if location_manager.respondsToSelector('requestWhenInUseAuthorization')
+        location_manager.requestWhenInUseAuthorization
+      end
+
+      set_show_user_location true
+    end
+
+    def hide_user_location
+      set_show_user_location false
+    end
+
+    def set_show_user_location(show)
+      self.view.showsUserLocation = show
+    end
+
+    def showing_user_location?
+      self.view.showsUserLocation
+    end
+
+    def user_location
+      user_annotation.nil? ? nil : user_annotation.coordinate
+    end
+
+    def user_annotation
+      self.view.userLocation.location.nil? ? nil : self.view.userLocation.location
+    end
+
+    def zoom_to_user(radius = 0.05, animated=true)
+      show_user_location unless showing_user_location?
+      set_region(MACoordinateRegionMakeWithDistance(user_location, radius, radius), animated)
+    end
+
+    def annotations
+      @promotion_annotation_data
+    end
+
+    def select_annotation(annotation, animated=true)
+      self.view.selectAnnotation(annotation, animated:animated)
+    end
+
+    def select_annotation_at(annotation_index, animated=true)
+      select_annotation(annotations[annotation_index], animated:animated)
+    end
+
+    def selected_annotations
+      self.view.selectedAnnotations
+    end
+
+    def deselect_annotations(animated=false)
+      unless selected_annotations.nil?
+        selected_annotations.each do |annotation|
+          self.view.deselectAnnotation(annotation, animated:animated)
+        end
+      end
+    end
+
+    def add_annotation(annotation)
+      @promotion_annotation_data << MapScreenAnnotation.new(annotation)
+      self.view.addAnnotation @promotion_annotation_data.last
+    end
+
+    def add_annotations(annotations)
+      @promotion_annotation_data = Array(annotations).map{|a| MapScreenAnnotation.new(a)}
+      self.view.addAnnotations @promotion_annotation_data
+    end
+
+    def clear_annotations
+      @promotion_annotation_data.each do |a|
+        self.view.removeAnnotation(a)
+      end
+      @promotion_annotation_data = []
+    end
+
+    def annotation_view(map_view, annotation)
+      return if annotation.is_a? MAUserLocation
+
+      params = annotation.params
+
+      identifier = params[:identifier]
+      if view = map_view.dequeueReusableAnnotationViewWithIdentifier(identifier)
+        view.annotation = annotation
+      else
+        # Set the pin properties
+        if params[:image]
+          view = MAAnnotationView.alloc.initWithAnnotation(annotation, reuseIdentifier:identifier)
+        else
+          view = MAPinAnnotationView.alloc.initWithAnnotation(annotation, reuseIdentifier:identifier)
+        end
+      end
+      view.image = params[:image] if view.respond_to?("image=") && params[:image]
+      view.animatesDrop = params[:animates_drop] if view.respond_to?("animatesDrop=")
+      view.pinColor = params[:pin_color] if view.respond_to?("pinColor=")
+      view.canShowCallout = params[:show_callout] if view.respond_to?("canShowCallout=")
+
+      if params[:left_accessory]
+        view.leftCalloutAccessoryView = params[:left_accessory]
+      end
+      if params[:right_accessory]
+        view.rightCalloutAccessoryView = params[:right_accessory]
+      end
+
+      if params[:action]
+        button_type = params[:action_button_type] || UIButtonTypeDetailDisclosure
+
+        action_button = UIButton.buttonWithType(button_type)
+        action_button.addTarget(self, action: params[:action], forControlEvents:UIControlEventTouchUpInside)
+
+        view.rightCalloutAccessoryView = action_button
+      end
+      view
+    end
+
+    def set_start_position(params={})
+      params[:latitude] ||= 37.331789
+      params[:longitude] ||= -122.029620
+      params[:radius] ||= 10
+
+      meters_per_mile = 1609.344
+
+      initialLocation = CLLocationCoordinate2D.new(params[:latitude], params[:longitude])
+      region = MACoordinateRegionMakeWithDistance(initialLocation, params[:radius] * meters_per_mile, params[:radius] * meters_per_mile)
+      set_region(region, animated:false)
+    end
+
+    def set_up_start_position
+      if self.class.respond_to?(:get_start_position) && self.class.get_start_position
+        self.set_start_position self.class.get_start_position_params
+      end
+    end
+
+    # TODO: Why is this so complex?
+    def zoom_to_fit_annotations(args={})
+      # Preserve backwards compatibility
+      args = {animated: args} if args == true || args == false
+      args = {animated: true, include_user: false}.merge(args)
+
+      ann = args[:include_user] ? (annotations + [user_annotation]).compact : annotations
+
+      #Don't attempt the rezoom of there are no pins
+      return if ann.count == 0
+
+      #Set some crazy boundaries
+      topLeft = CLLocationCoordinate2D.new(-90, 180)
+      bottomRight = CLLocationCoordinate2D.new(90, -180)
+
+      #Find the bounds of the pins
+      ann.each do |a|
+        topLeft.longitude = [topLeft.longitude, a.coordinate.longitude].min
+        topLeft.latitude = [topLeft.latitude, a.coordinate.latitude].max
+        bottomRight.longitude = [bottomRight.longitude, a.coordinate.longitude].max
+        bottomRight.latitude = [bottomRight.latitude, a.coordinate.latitude].min
+      end
+
+      #Find the bounds of all the pins and set the map_view
+      coord = CLLocationCoordinate2D.new(
+        topLeft.latitude - (topLeft.latitude - bottomRight.latitude) * 0.5,
+        topLeft.longitude + (bottomRight.longitude - topLeft.longitude) * 0.5
+      )
+
+      # Add some padding to the edges
+      #span = MACoordinateSpanMake(
+      #  long = ((topLeft.latitude - bottomRight.latitude) * 1.075).abs,
+      #  lat = ((bottomRight.longitude - topLeft.longitude) * 1.075).abs
+      #)
+
+      region = MACoordinateRegionMakeWithDistance(coord, long, lat)
+      fits = self.view.regionThatFits(region)
+
+      set_region(fits, animated: args[:animated])
+    end
+
+    def set_region(region, animated=true)
+      self.view.setRegion(region, animated:animated)
+    end
+
+    def region(params)
+      return nil unless params.is_a? Hash
+
+      params[:coordinate] = CLLocationCoordinate2D.new(params[:coordinate][:latitude], params[:coordinate][:longitude]) if params[:coordinate].is_a? Hash
+      #params[:span] = MACoordinateSpanMake(params[:span][0], params[:span][1]) if params[:span].is_a? Array
+
+      if params[:coordinate] && params[:span]
+        MACoordinateRegionMakeWithDistance( params[:coordinate], params[:span][0], params[:span][1] )
+      end
+    end
+
+    def look_up_address(args={}, &callback)
+      args[:address] = args if args.is_a? String # Assume if a string is passed that they want an address
+
+      geocoder = CLGeocoder.new
+      return geocoder.geocodeAddressDictionary(args[:address], completionHandler: callback) if args[:address].is_a?(Hash)
+      return geocoder.geocodeAddressString(args[:address].to_s, completionHandler: callback) unless args[:region]
+      return geocoder.geocodeAddressString(args[:address].to_s, inRegion:args[:region].to_s, completionHandler: callback) if args[:region]
+    end
+
+    ########## Cocoa touch methods #################
+    def mapView(map_view, viewForAnnotation:annotation)
+      annotation_view(map_view, annotation)
+    end
+
+    def mapView(map_view, didUpdateUserLocation:userLocation)
+      if self.respond_to?(:on_user_location)
+        on_user_location(userLocation)
+      else
+        PM.logger.info "You're tracking the user's location but have not implemented the #on_user_location(location) method in MapScreen #{self.class.to_s}."
+      end
+    end
+
+    ########## Cocoa touch Ruby counterparts #################
+
+    def type
+      map.mapType
+    end
+
+    def type=(type)
+      map.mapType = type
+    end
+
+    %w(zoom scroll pitch rotate).each do |meth|
+      define_method("#{meth}_enabled?") do
+        map.send("is#{meth.capitalize}Enabled")
+      end
+
+      define_method("#{meth}_enabled=") do |argument|
+        map.send("#{meth}Enabled=", argument)
+      end
+    end
+
+    module MapClassMethods
+      def start_position(params={})
+        @start_position_params = params
+        @start_position = true
+      end
+
+      def get_start_position_params
+        @start_position_params ||= nil
+      end
+
+      def get_start_position
+        @start_position ||= false
+      end
+    end
+    def self.included(base)
+      base.extend(MapClassMethods)
+    end
+
+    private
+
+    def location_manager
+      @location_manager ||= CLLocationManager.alloc.init
+      @location_manager.delegate ||= self
+      @location_manager
+    end
+
+
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: ProMotion-amap
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Mark Rickert
+- Jamon Holmgren
+- David Ruan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ProMotion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: motion-cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: motion-stump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: motion-redgreen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !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'
+description: Adds PM::MapScreen support to ProMotion. Using AMap
+email:
+- mark@mohawkapps.com
+- jamon@clearsightstudio.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ProMotion-map.rb
+- lib/ProMotion/map/map_screen.rb
+- lib/ProMotion/map/map_screen_annotation.rb
+- lib/ProMotion/map/map_screen_module.rb
+homepage: https://github.com/ruanwz/ProMotion-amap
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Adds PM::MapScreen support to ProMotion. Extracted from ProMotion.
+test_files: []