citibike 0.0.1

data/lib/citibike/client.rb

@@ -0,0 +1,104 @@
+# encoding: UTF-8
+
+require 'citibike/api'
+require 'citibike/response'
+
+module Citibike
+
+  # Client for interacting with the Citibike NYC
+  # unofficial API
+  class Client
+
+    attr_reader :options, :connection
+
+    VALID_KEYS = [:unwrapped]
+
+    def initialize(opts = {})
+      @options = {}
+      # Parse out the valid keys for this class
+      VALID_KEYS.each do |vk|
+        @options[vk] = opts[vk]
+      end
+
+      # Raw forces unwrapped to be true
+      if opts[:raw]
+        @options[:unwrapped] = true
+      end
+
+      @connection = Citibike::Connection.new(opts)
+    end
+
+    #
+    # Wrapper around a call to list all stations
+    #
+    # @return [Response] [A response object unless]
+    def stations
+      resp = self.connection.request(
+        :get,
+        Citibike::Station.path
+      )
+
+      return resp if @options[:unwrapped]
+
+      Citibike::Responses::Station.new(resp)
+    end
+
+    def helmets
+      resp = self.connection.request(
+        :get,
+        Citibike::Station.path
+      )
+
+      return resp if @options[:unwrapped]
+
+      Citibike::Responses::Helmet.new(resp)
+    end
+
+    def branches
+      resp = self.connection.request(
+        :get,
+        Citibike::Station.path
+      )
+
+      return resp if @options[:unwrapped]
+
+      Citibike::Responses::Branch.new(resp)
+    end
+
+    def self.stations
+      Citibike::Responses::Station.new(
+        # create a new connection in case
+        self.connection.request(
+          :get,
+          Citibike::Station.path
+        )
+      )
+    end
+
+    def self.helmets
+      Citibike::Responses::Helmet.new(
+        self.connection.request(
+          :get,
+          Citibike::Helmet.path
+        )
+      )
+    end
+
+    def self.branches
+      Citibike::Responses::Branch.new(
+        self.connection.request(
+          :get,
+          Citibike::Branch.path
+        )
+      )
+    end
+
+    private
+
+      def self.connection
+        @connection ||= Citibike::Connection.new
+      end
+
+  end
+
+end

data/lib/citibike/connection.rb

@@ -0,0 +1,85 @@
+# encoding: UTF-8
+
+require 'faraday'
+require 'faraday_middleware'
+require 'yajl'
+
+module Citibike
+  # Class representing a Faraday instance used to connect to the
+  # actual Citibike API, takes a variety of options
+  class Connection
+
+    def initialize(opts = {})
+      @options = {
+        adapter: Faraday.default_adapter,
+        headers: {
+          'Accept' => 'application/json; charset=utf-8',
+          'UserAgent' => 'Citibike Gem'
+        },
+        proxy: nil,
+        ssl: {
+          verify: false
+        },
+        debug: false,
+        test: false,
+        stubs: nil,
+        raw: false,
+        format_path: true,
+        format: :json,
+        url: 'http://appservices.citibikenyc.com/'
+      }
+      # Reject any keys that aren't already in @options
+      @options.keys.each do |k|
+        @options[k] = opts[k] if opts.key?(k)
+      end
+    end
+
+    def http
+      @http ||= Faraday.new(@options) do |connection|
+        connection.use Faraday::Request::UrlEncoded
+        connection.use Faraday::Response::ParseJson unless @options[:raw]
+        connection.use Faraday::Response::Logger if @options[:debug]
+        if @options[:test]
+          connection.adapter(@options[:adapter], @options[:stubs])
+        else
+          connection.adapter(@options[:adapter])
+        end
+      end
+    end
+
+    #
+    # Makes a request to the API through the set up interface
+    # @param  method [Symbol] [:get, :post, :put, :delete]
+    # @param  path [String] [The path to request from the server]
+    # @param  options = {} [Optional Hash] [Args to include in the request]
+    #
+    # @return [String or Hash] [The result of the request, generally a hash]
+    def request(method, path, options = {})
+      if @options[:format_path]
+        path = format_path(path, @options[:format])
+      end
+      response = self.http.send(method) do |request|
+        case method
+        when :get, :delete
+          request.url(path, options)
+        when :post, :put
+          request.path = path
+          request.body = options unless options.empty?
+        end
+      end
+      response.body
+    end
+
+    private
+
+      def format_path(path, format)
+        if path =~ /\./
+          path
+        else
+          [path, format].map(&:to_s).compact.join('.')
+        end
+      end
+
+  end
+
+end

data/lib/citibike/response.rb

@@ -0,0 +1,119 @@
+# encoding: UTF-8
+
+module Citibike
+
+  # Base class that defines the shared behavior for
+  # all the different response types
+  class Response
+
+    include Enumerable
+
+    Dir[File.expand_path('../responses/*.rb', __FILE__)].each { |f| require f }
+
+    # allow direct access to the data stored in this object
+    attr_reader :data, :success, :last_update
+
+    # undefine methods from this class so they get proxied to data
+    undef_method :to_s, :inspect
+
+    # Initializes a Response object
+    # @param  data [Hash] [Response data from an api request]
+    #
+    # @return [Nil] [This return value is ignored]
+    def initialize(data)
+      @data = data['results']
+      @success = data['ok']
+      @last_update = Time.at(data['last_updated'].to_i)
+
+      # build the id_hash
+      @id_hash ||= {}
+      @data.each do |d|
+        @id_hash[d.id] = d
+      end
+    end
+
+    #
+    # Returns true if this holds a successful response
+    #
+    # @return [Boolean] [Whether the request succeeded]
+    def success?
+      @success == true
+    end
+
+    # each provided to include enumberable
+    # @param  &block [Block] [For enumerable]
+    #
+    # @return [Enumerable] [Another enumerable]
+    def each(&block)
+      self.data.each(&block)
+    end
+
+    #
+    # Clones this object and populates
+    # @param  data [Array] [Array of API objects]
+    #
+    # @return [Response] [A clone of self wrapping data]
+    def clone_with(data)
+      clone = self.clone
+      clone.instance_variable_set(:@data, data)
+      clone
+    end
+
+    #
+    # Finds the given object by id using a hash for a shortcut
+    # @param  id [Integer] [The id to lookup]
+    #
+    # @return [Citibike::Api] [Some type of API object e.g Helmet or Station]
+    def find_by_id(id)
+      id = id.to_i
+
+      @id_hash[id]
+    end
+
+    def find_by_ids(*ids)
+      ids.map { |i| self.find_by_id(i) }.compact
+    end
+
+    #
+    # Returns every object within dist (miles)
+    # of lat/long
+    #
+    # @param  lat [Float] [A latitude position]
+    # @param  long [Float] [A longitude position]
+    # @param  dist [Float] [A radius in miles]
+    #
+    # @return [Array] [Array of objects within dist of lat/long]
+    def all_within(lat, long, dist)
+      @data.select { |d| d.distance_from(lat, long) < dist }
+    end
+
+    #
+    # Returns every object within dist miles
+    # of obj
+    #
+    # @param  obj [Api] [Api Object]
+    # @param  dist [Float] [Distance to consider]
+    #
+    # @return [type] [description]
+    def all_near(obj, dist)
+      @data.select do |d|
+        if d.id == obj.id
+          false
+        else
+          d.distance_from(obj.latitude, obj.longitude) < dist
+        end
+      end
+    end
+
+    # Delegates any undefined methods to the underlying data
+    def method_missing(sym, *args, &block)
+      if self.data.respond_to?(sym)
+        return self.data.send(sym, *args, &block)
+      end
+
+      super
+    end
+
+  end
+
+end

data/lib/citibike/responses/branch.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+module Citibike
+  # Namespace for different response objects
+  # representing a list of api objects
+  module Responses
+    # Represents a list of Branch API objects
+    class Branch < Citibike::Response
+
+      #
+      # Transforms part of the input hash to the proper
+      # type of object.  Expects the keys:
+      # {
+      #   :data => [{...}, {...}],
+      #   :ok => true/false,
+      #   :last_updated => Time
+      # }
+      #
+      # @param  data [Hash] [A hash from the Citibike API]
+      #
+      # @return [nil] [Not used]
+      def initialize(data = {})
+        data['results'].map! { |r| Citibike::Branch.new(r) }
+        super
+      end
+
+    end
+
+  end
+
+end

data/lib/citibike/responses/helmet.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Citibike
+
+  module Responses
+    # Represents a list of Helmet API objects
+    class Helmet < Citibike::Response
+
+      def initialize(data)
+        data['results'].map! { |r| Citibike::Helmet.new(r) }
+        super
+      end
+
+    end
+
+  end
+
+end

data/lib/citibike/responses/station.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Citibike
+
+  module Responses
+    # Represents a list of Station api objects
+    class Station < Citibike::Response
+
+      def initialize(data)
+        data['results'].map! { |r| Citibike::Station.new(r) }
+        super
+      end
+
+    end
+
+  end
+
+end

data/lib/citibike/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+module Citibike
+  VERSION = '0.0.1'
+end

data/spec/lib/apis/station_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Citibike::Station do
+
+  let(:stations) do
+    Citibike.stations
+  end
+
+  let(:stat) do
+    stations.first
+  end
+
+  around(:each) do |example|
+    VCR.use_cassette(:station, record: :new_episodes) do
+      example.run
+    end
+  end
+
+  it "should provide consistent accessor methods" do
+    stat.nearby_stations.should be_a(Array)
+    # this field is nil for some reason
+    stat.should respond_to(:station_address)
+    stat.available_docks.should be_a(Integer)
+    stat.available_bikes.should be_a(Integer)
+
+    stat.should be_active
+  end
+
+  it "should provide a helper for nearby station ids" do
+    stat.nearby_station_ids.should be_a(Array)
+    stat.nearby_station_ids.first.should be_a(Integer)
+  end
+
+  context ".distance_to_nearby" do
+    it "should provide a helper to get the distance to a nearby station" do
+      stat.distance_to_nearby(
+        stat.nearby_station_ids.first
+      ).should be_a(Float)
+    end
+
+    it "should raise an error if the provided id is not nearby" do
+      lambda{
+        stat.distance_to_nearby(stat.nearby_station_ids.sum)
+      }.should raise_error
+    end
+  end
+
+end

data/spec/lib/citibike_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Citibike do
+
+  it "should proxy methods to Citibike::Client" do
+    Citibike::Client.expects(:stations)
+    Citibike::Client.expects(:helmets)
+    Citibike::Client.expects(:branches)
+
+    Citibike.stations
+    Citibike.helmets
+    Citibike.branches
+  end
+
+end