rubybikes 0.3.0

data/data/pybikes/youbike.json

@@ -0,0 +1,173 @@
+{
+    "system": "youbike",
+    "class": {
+        "YouBikeTw": {
+            "instances":[
+                {
+                    "tag": "youbike-new-taipei",
+                    "uid": "05",
+                    "meta": {
+                        "city": "新北市 New Taipei",
+                        "country": "TW",
+                        "latitude": 25.0169826,
+                        "longitude": 121.4627868
+                    }
+                },
+                {
+                    "tag": "youbike-taipei",
+                    "uid": "00",
+                    "meta": {
+                        "city": "台北市 Taipei City",
+                        "country": "TW",
+                        "latitude": 25.0329636,
+                        "longitude": 121.5654268
+                    }
+                },
+                {
+                    "tag": "youbike-taoyuan",
+                    "uid": "07",
+                    "meta": {
+                        "city": "桃園市 Taoyuan City",
+                        "country": "TW",
+                        "latitude": 24.9936281,
+                        "longitude": 121.3009798
+                    }
+                },
+                {
+                    "tag": "youbike-taichung",
+                    "uid": "01",
+                    "meta": {
+                        "city": "臺中市 Taichung City",
+                        "country": "TW",
+                        "latitude": 24.1477358,
+                        "longitude": 120.6736482
+                    }
+                },
+                {
+                    "tag": "youbike-hsinchu-county",
+                    "uid": "0B",
+                    "meta": {
+                        "city": "新竹縣 Hsinchu County",
+                        "country": "TW",
+                        "latitude": 24.8269,
+                        "longitude": 121.0129
+                    }
+                },
+                {
+                    "tag": "youbike-hsinchu-city",
+                    "uid": "09",
+                    "meta": {
+                        "city": "新竹市 Hsinchu City",
+                        "country": "TW",
+                        "latitude": 24.8018,
+                        "longitude": 120.9714
+                    }
+                },
+                {
+                    "tag": "youbike-hsinchu-science-park",
+                    "uid": "10",
+                    "meta": {
+                        "city": "新竹科學工業園區 Hsinchu Science Park",
+                        "country": "TW",
+                        "latitude": 24.7818,
+                        "longitude": 121.0050
+                    }
+                },
+                {
+                    "tag": "youbike-miaoli-county",
+                    "uid": "0A",
+                    "meta": {
+                        "city": "台灣 Miaoli County",
+                        "country": "TW",
+                        "latitude": 24.5648,
+                        "longitude": 120.8185
+                    }
+                },
+                {
+                    "tag": "youbike-chiayi-city",
+                    "uid": "08",
+                    "meta": {
+                        "city": "台灣 Chiayi City",
+                        "country": "TW",
+                        "latitude": 23.4797,
+                        "longitude": 120.4397
+                    }
+                },
+                {
+                    "tag": "youbike-tainan-city",
+                    "uid": "13",
+                    "meta": {
+                        "city": "臺南市 Tainan City",
+                        "country": "TW",
+                        "latitude": 22.9923,
+                        "longitude": 120.1850
+                    }
+                },
+                {
+                    "tag": "youbike-kaohsiung-city",
+                    "uid": "12",
+                    "meta": {
+                        "city": "高雄市 Kaohsiung City",
+                        "country": "TW",
+                        "latitude": 22.6314,
+                        "longitude": 120.3018
+                    }
+                },
+                {
+                    "tag": "youbike-pingtung-county",
+                    "uid": "14",
+                    "meta": {
+                        "city": "屏東縣 Pingtung County",
+                        "country": "TW",
+                        "latitude": 22.6830,
+                        "longitude": 120.4879
+                    }
+                },
+                {
+                    "tag": "youbike-chiayi-county",
+                    "uid": "11",
+                    "meta": {
+                        "city": "嘉義縣 Chiayi County",
+                        "country": "TW",
+                        "latitude": 23.4592,
+                        "longitude": 120.2927
+                    }
+                },
+                {
+                    "tag": "youbike-taitung-county",
+                    "uid": "15",
+                    "meta": {
+                        "city": "臺東縣 Taitung County",
+                        "country": "TW",
+                        "latitude": 22.7557,
+                        "longitude": 121.1503
+                    }
+                },
+                {
+                    "tag": "youbike-guangfu-township",
+                    "uid": "16",
+                    "meta": {
+                        "city": "光復鄉 Guangfu Township",
+                        "country": "TW",
+                        "latitude": 23.6661,
+                        "longitude": 121.4215
+                    }
+                }
+            ]
+        },
+        "YouBikeCn": {
+            "instances": [
+                   {
+                    "tag": "youbike-putian-city",
+                    "meta": {
+                        "city": "莆田市 (Putian City)",
+                        "country": "CN",
+                        "latitude": 25.4504,
+                        "longitude": 119.0126
+                    },
+                    "feed_url": "https://apis.ptyoubike.com/api/front/station/all?lang=cn"
+                }
+            ]
+        }
+    }
+}

data/data/upstream.json

@@ -0,0 +1,7 @@
+{
+  "repository": "https://github.com/eskerda/pybikes",
+  "revision": "b8681d2344d2ccc61d7b99b089a8cdba167a169e",
+  "protocol": 1,
+  "baseline_clients": 85,
+  "baseline_networks": 815
+}

data/lib/rubybikes/engine.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'native' unless defined?(RubyBikes::Native::Engine)

data/lib/rubybikes/native/authenticated.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# Adapted from PyBikes authenticated clients; AGPL-3.0, original attribution in NOTICE.
+class RubyBikes
+  module Native
+    class JsonProviders
+      def update_bicimad
+        url = 'https://openapi.emtmadrid.es/v2/transport/bicimad/stations/'
+        raw = request(url)
+        if @transport.last_response.status == 401
+          auth = json('https://openapi.emtmadrid.es/v2/mobilitylabs/user/login/', headers: { 'passkey' => @key.fetch('passkey'), 'x-clientid' => @key.fetch('clientid') })
+          @transport.headers['accesstoken'] = auth.fetch('data').first.fetch('accessToken')
+          raw = request(url, skip_cache: true)
+        end
+        JSON.parse(raw).fetch('data').each do |s|
+          online = s['activate'] == 1 && s['no_available'] == 0 # rubocop:disable Style/NumericPredicate -- JSON fields may contain non-numeric values.
+          station(s['name'], s['geometry']['coordinates'][1], s['geometry']['coordinates'][0], number(s['dock_bikes']), number(s['free_bases']),
+                  { 'number' => s['number'], 'uid' => s['id'], 'address' => s['address'], 'online' => online,
+                    'slots' => number(s['total_bases']), 'light' => %w[green red yellow gray].fetch(number(s['light'])) })
+        end
+      end
+
+      def update_bikeshare_ie
+        headers = {
+          'Authorization' => "Basic #{@key}",
+          'User-Agent' => 'Dalvik/2.1.0 (Linux; U; Android 11; ROCINANTE FIRE Build/9001'
+        }
+        json('https://apps.bikeshare.ie/rbs/resources/appapi/station/data/list',
+             method: 'POST', data: { 'schemeId' => p('system_id').to_s }, headers: headers).fetch('data').each do |s|
+          station(s['name'], s['latitude'], s['longitude'], number(s['bikesAvailable']), number(s['docksAvailable']),
+                  { 'uid' => s['stationId'], 'slots' => number(s['docksCount']), 'name_ie' => s['nameIrish'] })
+        end
+      end
+
+      def update_weelo
+        @transport.headers['User-Agent'] = 'okhttp/4.9.1'
+        Array(p('city_ids')).each do |city|
+          url = 'https://api.weelo.it/resources/stations'
+          params = { 'idCity' => city, 'serviceType' => 1 }
+          raw = request(url, params: params)
+          if @transport.last_response.status == 401
+            token = json('https://api.weelo.it/connect/token', method: 'POST', data: @key.merge('grant_type' => 'client_credentials')).fetch('access_token')
+            @transport.headers['Authorization'] = "Bearer #{token}"
+            raw = request(url, params: params, skip_cache: true)
+          end
+          JSON.parse(raw).each do |s|
+            normal, electric = s.fetch('countMuscularBikesAvailable'), s.fetch('countAssistedBikesAvailable')
+            station(s['name'], s['latitude'], s['longitude'], normal + electric, s['countFreePlacesAvailable'],
+                    { 'uid' => s['idStation'], 'address' => s['address'], 'has_ebikes' => true, 'ebikes' => electric,
+                      'normal_bikes' => normal, 'status' => s['state'], 'slots' => s['totalPlaces'] })
+          end
+        end
+      end
+
+      def update_nubija
+        json('https://ar.nubija.com:55789/v1/station/list/user', headers: { 'app-token' => @key[8...-8], 'User-Agent' => 'okhttp/3.14.9' }).fetch('station').each do |s|
+          next unless s['area'] == p('area')
+
+          station(s['station_cd'], s['x_pos'], s['y_pos'], 0, number(s['parking_count']),
+                  { 'uid' => s['id'], 'number' => number(s['tmno']), 'address' => s['address'] })
+        end
+      end
+
+      def update_bicicard
+        headers = { 'User-Agent' => 'Dalvik/2.1.0 (Linux; U; Android 11; ROCINANTE FIRE Build/9001', 'DeviceModel' => 'ROCINANTE FIRE' }
+        cert = lower_keys(json("#{p('endpoint')}/api/certificado", headers: headers))
+        headers['Thumbprint'] = cert.fetch('thumbprint')
+        lower_keys(json("#{p('endpoint')}/apiapp/SBancada/Estado/TodosSimple", headers: headers, skip_cache: true)).each do |s|
+          normal, electric = s.fetch('numerobicicletasnormales'), s.fetch('numerobicicletaselectricas')
+          station(s['nombre'], s['latitud'], s['longitud'], normal + electric, s['numerocandadoslibres'],
+                  { 'uid' => s['id'], 'normal_bikes' => normal, 'ebikes' => electric, 'slots' => s['numerocandados'], 'online' => s['ispuestoonline'] })
+        end
+      end
+
+      def update_ov_fiets
+        params = { 'minLat' => 50.2876, 'minLng' => 2.7109, 'maxLat' => 53.8857, 'maxLng' => 7.9541, 'zoomLevel' => 9, 'limit' => 500,
+                   'filterTypes' => ['OV_FIETS'], 'appVersionCapabilities' => %w[DLF-Tier DLS-Check DLA-GreenWheels], 'enableSubfilters' => true }
+        json('https://gateway.apiportal.ns.nl/places-api/v2/nearbyme', params: params,
+                                                                       headers: { 'X-MmVehicleExtra' => 'false',
+                                                                                  'Ocp-Apim-Subscription-Key' => @key }).fetch('locations').each do |s|
+          bikes = s['description']['subDescription'][/\d+/].to_i
+          station(s['description']['full'], s['lat'], s['lng'], bikes, nil, { 'uid' => s['id']['value'][/.*-(\w+)\s*$/, 1] })
+        end
+      end
+
+      def lower_keys(value)
+        case value
+        when Hash then value.to_h { |key, item| [key.downcase, lower_keys(item)] }
+        when Array then value.map { |item| lower_keys(item) }
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/rubybikes/native/engine.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+class RubyBikes
+  module Native
+    class Engine
+      MANIFEST = JSON.parse(File.read(File.join(DATA, 'upstream.json'))).freeze
+
+      attr_reader :timeout
+
+      def initialize(timeout: 60)
+        @timeout = Float(timeout)
+        raise ArgumentError, 'timeout must be positive' unless @timeout.positive? && @timeout.finite?
+
+        @providers = JSON.parse(File.read(File.join(DATA, 'providers.json')))
+        @definitions = {}
+        Dir[File.join(DATA, 'pybikes/*.json')].each do |file|
+          schema = JSON.parse(File.read(file))
+          classes = schema['class'].is_a?(Hash) ? schema['class'] : { schema['class'] => schema }
+          classes.each do |name, group|
+            catalog_instances(group['instances']).each do |params|
+              @definitions[params.fetch('tag')] = { 'module' => schema.fetch('system'), 'class' => name, 'parameters' => params }
+            end
+          end
+        end
+        @mutex = Mutex.new
+        @cooldowns = {}
+        @systems = {}
+        @response_cache = ResponseCache.new
+      end
+
+      def request(operation, timeout: @timeout, **arguments)
+        result = @mutex.synchronize do
+          case operation
+          when 'version'
+            { 'implementation' => 'ruby', 'version' => RubyBikes::VERSION, 'revision' => MANIFEST.fetch('revision'), 'protocol' => 1 }
+          when 'providers'
+            { 'providers' => @providers.map { |spec| spec.except('meta', 'gbfs', 'required_parameters') } }
+          when 'catalog'
+            networks = @definitions.map do |tag, definition|
+              spec = find_spec(definition)
+              { 'tag' => tag, 'module' => spec['module'], 'class' => spec['class'], 'label' => spec['label'],
+                'authed' => spec['authed'], 'sync' => spec['sync'], 'unifeed' => spec['unifeed'],
+                'endpoint_host' => URI(definition['parameters']['feed_url'] || definition['parameters']['endpoint'] || '').host,
+                'meta' => spec.fetch('meta').merge(definition['parameters'].fetch('meta')) }
+            end
+            { 'networks' => networks.sort_by { |row| row['tag'] } }
+          when 'describe', 'update'
+            definition = arguments[:definition] || @definitions[arguments.fetch(:tag)]
+            raise NoSystemFoundError, 'Unknown system tag' unless definition
+
+            spec = find_spec(definition)
+            params = definition.fetch('parameters').merge('tag' => arguments.fetch(:tag))
+            missing = spec.fetch('required_parameters').reject { |name| params.key?(name) }
+            raise ProviderError, "Missing provider parameters: #{missing.join(', ')}" unless missing.empty?
+
+            klass = if spec['gbfs']
+                      Gbfs
+                    elsif %w[Nextbike Bizkaibizi].include?(spec['class'])
+                      Nextbike
+                    else
+                      JsonProviders
+                    end
+            key = JSON.parse(JSON.generate(arguments[:key]))
+            identity = JSON.generate([arguments.fetch(:tag), key, definition])
+            provider = @systems[identity] ||= klass.new(spec, params, key: key)
+            if operation == 'describe'
+              { 'tag' => provider.tag, 'meta' => provider.meta, 'module' => spec['module'], 'class' => spec['class'],
+                'authed' => spec['authed'], 'sync' => spec['sync'], 'unifeed' => spec['unifeed'] }
+            else
+              options = JSON.parse(JSON.generate(arguments[:scraper] || {})).transform_keys(&:to_sym)
+              cooldowns = @cooldowns.merge(options.delete(:cooldowns) || {})
+              begin
+                cache = spec['unifeed'] && !spec['authed'] ? @response_cache : nil
+                transport = Transport.new(timeout: timeout, cooldowns: cooldowns, cache: cache, **options)
+                transport.within_deadline { provider.snapshot(transport) }
+              ensure
+                @cooldowns.merge!(cooldowns)
+              end
+            end
+          else
+            raise ArgumentError, 'Unknown engine operation'
+          end
+        end
+        JSON.parse(JSON.generate(result))
+      rescue Error
+        raise
+      rescue StandardError => e
+        raise ProviderError, "Provider update failed (#{e.class.name})"
+      end
+
+      def close; end
+
+      private
+
+      def catalog_instances(value) = Array(value)
+
+      def find_spec(definition)
+        @providers.find { |spec| spec['module'] == definition['module'] && spec['class'] == definition['class'] } ||
+          raise(NoSystemFoundError, 'Unknown provider class')
+      end
+    end
+  end
+end

data/lib/rubybikes/native/gbfs.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# Adapted from PyBikes gbfs.py, Copyright eskerda and contributors, AGPL-3.0.
+class RubyBikes
+  module Native
+    class Gbfs < Provider
+      def initialize(spec, parameters, key: nil)
+        super
+        @feed_url = case spec.fetch('class')
+                    when 'BCycle'
+                      @meta['company'] = @parameters['meta']['company'] + spec.fetch('meta').fetch('company') if @parameters.fetch('meta').key?('company')
+                      "https://gbfs.bcycle.com/#{@parameters.fetch('uid')}/gbfs.json"
+                    when 'Cyclocity' then "https://api.cyclocity.fr/contracts/#{@parameters.fetch('contract').downcase}/gbfs/gbfs.json"
+                    when 'Ecovelo' then "https://api.gbfs.ecovelo.mobi/#{@parameters.fetch('dataset')}/gbfs.json"
+                    when 'Careem' then 'https://dubai.publicbikesystem.net/customer/gbfs/v2/en/gbfs.json'
+                    when 'Ambici' then 'https://gbfs.nextbike.net/maps/gbfs/v2/nextbike_bs/gbfs.json'
+                    when 'NextbikeGbfs' then "https://gbfs.nextbike.net/maps/gbfs/v2/nextbike_#{@parameters.fetch('domain')}/gbfs.json"
+                    when 'DB', 'Callabike'
+                      domain = spec['class'] == 'Callabike' ? 'CallABike' : @parameters.fetch('provider')
+                      "https://apis.deutschebahn.com/db-api-marketplace/apis/shared-mobility-gbfs/v2/de/#{domain}/gbfs"
+                    when 'HelloCycling', 'Docomo'
+                      name = spec['class'] == 'Docomo' ? 'docomo-cycle' : 'hellocycling'
+                      features = JSON.parse(File.read(File.join(Native::DATA, 'geojson/japan_prefectures.json'))).fetch('features')
+                      feature = features.find { |item| item['properties']['id'] == @parameters.fetch('uid') }
+                      raise ArgumentError, 'Unknown Japanese prefecture' unless feature
+
+                      @parameters['bbox'] = feature.fetch('geometry')
+                      "https://api-public.odpt.org/api/v4/gbfs/#{name}/gbfs.json"
+                    else @parameters.fetch('feed_url')
+                    end
+        @meta['gbfs_href'] = @feed_url
+      end
+
+      def update
+        case spec.fetch('class')
+        when 'DB', 'Callabike'
+          @transport.headers.merge!('DB-Client-Id' => @key.fetch('client_id'), 'DB-Api-Key' => @key.fetch('client_secret'), 'Accept' => 'application/json')
+        when 'SharedMobility'
+          @transport.headers['Authorization'] = @key
+        end
+        args = p('append_feed_args_to_req') ? URI.decode_www_form(URI(@feed_url).query || '') : nil
+        feeds = discover_feeds(args)
+        information = json(feeds.fetch('station_information'), params: args).fetch('data').fetch('stations')
+        statuses = json(feeds.fetch('station_status'), params: args).fetch('data').fetch('stations').to_h { |item| [item.fetch('station_id'), item] }
+        # @type var types: Hash[String, untyped]
+        types = if feeds['vehicle_types']
+                  json(feeds['vehicle_types'], params: args).fetch('data').fetch('vehicle_types', list(nil)).to_h { |item| [item.fetch('vehicle_type_id'), item] }
+                else
+                  {}
+                end
+        information.to_h { |item| [item.fetch('station_id'), item] }.each_value do |item|
+          next unless statuses.key?(item['station_id'])
+          next if p('region_id') && item['region_id'] != p('region_id')
+
+          item = item.merge(statuses.fetch(item['station_id']).compact)
+          next unless truthy?(item.fetch('is_installed'))
+
+          begin
+            parse_gbfs_station(item, types)
+          rescue RubyBikes::Error
+            raise
+          rescue StandardError
+            raise unless p('ignore_errors')
+          end
+        end
+        vehicles_feed = feeds['free_bike_status'] || feeds['vehicle_status']
+        return unless vehicles_feed
+
+        data = json(vehicles_feed, params: args).fetch('data')
+        list(data['bikes'] || data['vehicles']).each do |item|
+          next if item.key?('station_id')
+
+          kind = if item['vehicle_type_id']
+                   type = types[item['vehicle_type_id']]
+                   next unless type
+
+                   vehicle_kind(type).last
+                 else
+                   'bike'
+                 end
+          next unless kind
+
+          kind = { 'electric_bike' => 'ebike', 'electric_scooter' => 'scooter' }.fetch(item['type'], kind)
+          extra = { 'uid' => item['bike_id'] || item['vehicle_id'], 'online' => !truthy?(item.fetch('is_disabled')) }
+          extra['battery'] = Float(item['current_fuel_percent']) if item.key?('current_fuel_percent')
+          vehicle(item.fetch('lat'), item.fetch('lon'), extra, kind)
+        end
+      end
+
+      def vehicle_kind(type)
+        form, power = type.values_at('form_factor', 'propulsion_type')
+        return %w[scooters scooter] if form.is_a?(String) && form.include?('scooter') && power == 'electric'
+        return %w[cargo bike] if form == 'cargo_bicycle' && power == 'human'
+        return %w[ecargo ebike] if form == 'cargo_bicycle' && power == 'electric_assist'
+        return %w[normal_bikes bike] if form == 'bicycle' && power == 'human'
+        return %w[ebikes ebike] if form == 'bicycle' && %w[electric_assist electric].include?(power)
+
+        [nil, nil]
+      end
+
+      private
+
+      def discover_feeds(args)
+        feeds = %w[station_information station_status vehicle_types free_bike_status vehicle_status].to_h { |name| [name, p(name)] }.compact
+        if feeds.empty?
+          raw = request(@feed_url, params: args)
+          if @transport.last_response.status >= 400
+            raise ProviderError, 'Provider authorization failed' if @transport.last_response.status == 401
+
+            feeds = %w[station_information station_status].to_h { |name| [name, URI.join(@feed_url, "#{name}.json").to_s] }
+          else
+            data = JSON.parse(raw).fetch('data')
+            data = data['en'] || data.values.last if data.is_a?(Hash) && !data.key?('feeds')
+            data = data.fetch('feeds') if data.is_a?(Hash)
+            feeds = data.to_h { |feed| [feed.fetch('name'), feed.fetch('url')] }
+          end
+        end
+        feeds.transform_values { |url| p('force_https') ? url.sub(/^http:/, 'https:') : url }
+      end
+
+      def parse_gbfs_station(item, types)
+        name = item['name'].is_a?(Array) ? item['name'].first.fetch('text') : item['name']
+        bikes = integer(item.key?('num_bikes_available') ? item['num_bikes_available'] : item['num_vehicles_available'])
+        extra = { 'uid' => item['station_id'], 'renting' => item.fetch('is_renting'), 'returning' => item.fetch('is_returning'),
+                  'virtual' => item.fetch('is_virtual_station', false) }
+        extra['last_updated'] = iso_date(item['last_reported']) if item.key?('last_reported')
+        %w[address post_code altitude].each { |field| extra[field] = item[field] if item.key?(field) }
+        extra['rental_uris'] = item['rental_uris'].slice('android', 'ios', 'web') if item['rental_uris'].is_a?(Hash)
+        extra['slots'] = item['capacity'] if item.key?('capacity')
+        if item.key?('rental_methods')
+          extra['payment'] = item['rental_methods'].map(&:downcase)
+          extra['payment-terminal'] = extra['payment'].include?('creditcard')
+        end
+        extra.merge!('has_ebikes' => true, 'ebikes' => integer(item['num_ebikes_available'])) if item.key?('num_ebikes_available')
+        available_types = item['num_bikes_available_types']
+        if available_types.is_a?(Hash) && available_types.key?('ebike')
+          extra.merge!('has_ebikes' => true, 'ebikes' => integer(available_types['ebike']), 'normal_bikes' => integer(available_types.fetch('mechanical')))
+        end
+        list(item['vehicle_types_available']).each do |available|
+          type = types[available['vehicle_type_id']]
+          next unless type
+
+          field, = vehicle_kind(type)
+          next unless field
+
+          extra[field] = extra.fetch(field, 0) + available.fetch('count')
+          extra["has_#{field}"] = true unless field == 'normal_bikes'
+        end
+        bikes = extra.fetch('normal_bikes', 0) + extra.fetch('ebikes', 0) if item.key?('vehicle_types_available') && (!bikes || bikes.zero?)
+        case spec['class']
+        when 'Velib'
+          extra['uid'] = item.fetch('stationCode')
+          extra['station_id'] = item.fetch('station_id')
+          extra['banking'] = extra.fetch('payment', []).include?('creditcard')
+          extra['payment-terminal'] = extra['banking']
+          list(available_types).each do |type|
+            next unless type.is_a?(Hash)
+
+            extra['ebikes'] = number(type['ebike']) if type.key?('ebike')
+            extra['normal_bikes'] = number(type['mechanical']) if type.key?('mechanical')
+          end
+        when 'BCycle'
+          extra.merge!('has_ebikes' => true, 'ebikes' => number(available_types.fetch('electric')), 'normal_bikes' => number(available_types.fetch('classic')))
+        end
+        station(name, item.fetch('lat'), item.fetch('lon'), bikes, integer(item['num_docks_available']), extra)
+      end
+    end
+  end
+end

data/lib/rubybikes/native/geometry.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class RubyBikes
+  module Native
+    module Geometry
+      module_function
+
+      def contains?(bounds, latitude, longitude)
+        return true unless bounds && !bounds.empty?
+
+        if bounds.is_a?(Array)
+          unless bounds.length == 4 || (bounds.length == 2 && bounds.all? { |point| point.is_a?(Array) && point.length == 2 })
+            raise ArgumentError, 'Bounds must contain four coordinates or two latitude/longitude pairs'
+          end
+
+          west, south, east, north = bounds.length == 4 ? bounds : [bounds[1][1], bounds[1][0], bounds[0][1], bounds[0][0]]
+          horizontal = [Float(west, exception: true), Float(east, exception: true)].sort
+          vertical = [Float(south, exception: true), Float(north, exception: true)].sort
+          west, east = horizontal.fetch(0), horizontal.fetch(1)
+          south, north = vertical.fetch(0), vertical.fetch(1)
+          return west < longitude && longitude < east && south < latitude && latitude < north
+        end
+        geometry = bounds['geometry'] || bounds
+        case geometry.fetch('type')
+        when 'FeatureCollection'
+          geometry.fetch('features').any? { |feature| contains?(feature, latitude, longitude) }
+        when 'Polygon'
+          polygon?(geometry.fetch('coordinates'), longitude, latitude)
+        when 'MultiPolygon'
+          geometry.fetch('coordinates').any? { |polygon| polygon?(polygon, longitude, latitude) }
+        else
+          raise ArgumentError, 'Unsupported geographic bounds'
+        end
+      end
+
+      def polygon?(rings, x, y)
+        ring(rings.first, x, y) == :inside && rings.drop(1).all? { |hole| ring(hole, x, y) == :outside }
+      end
+
+      def ring(points, x, y)
+        inside = false
+        points.each_with_index do |(ax, ay), index|
+          bx, by = points[(index + 1) % points.size]
+          cross = ((x - ax) * (by - ay)) - ((y - ay) * (bx - ax))
+          return :boundary if cross.zero? && x.between?(*[ax, bx].minmax) && y.between?(*[ay, by].minmax)
+
+          inside = !inside if (ay > y) != (by > y) && x < ((bx - ax) * (y - ay) / (by - ay).to_f) + ax
+        end
+        inside ? :inside : :outside
+      end
+    end
+  end
+end