LBF 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5284874c3a5f3f19e9467153016a4fa96cf2a7d9
+  data.tar.gz: 651b62e651a3486a79d320753eeb2e1febb2b8eb
+SHA512:
+  metadata.gz: d1f779461701be841101cd36951db59f8d4be2768a7298c1445d6948ed7d5fa9ab596632561798fa77b8b7e5a3007b22fb7a5ed439754fe0d68260c8f3a7ec39
+  data.tar.gz: de78338b81f2e7ce4c1044f9d9b1b752aa2095c5a8151790b3dc807b54026233f53a211724e89f0a87597e441ec4144afb5ae03b7a91f0608a334f588000e694

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+go.rb

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> <copyright holders>
+
+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,52 @@
+# LBF
+
+This is a big ol' pile of nested service objects for interacting with the Look
+Buy Fly SOAP API.
+
+**This is a work in progress**
+
+#### Todo:
+* Make dependencies leaner (don't require activesupport/all)
+* Tests!
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lbf'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lbf
+
+## Usage
+
+```ruby
+require 'lbf'
+
+client = LBF::Client.new(username:  'lbf_username', # required
+                         url_id:    '42',           # required
+                         password:  'lbf_password', # required
+                        )
+
+request = LBF::Request.new(origin:        'sdf',                  # required
+                           destination:   'sna',                  # required
+                           ip:            '208.73.215.97',        # required
+                           departure_date: Date.tomorrow,         # required
+                           return_date:    Date.tomorrow + 7.days # optional
+                          )
+client.search request
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/oversee-ffleming/lbf/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lbf.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lbf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "LBF"
+  spec.version       = LBF::VERSION
+  spec.authors       = ["Forrest Fleming"]
+  spec.email         = ["ffleming@oversee.net"]
+  spec.summary       = %q{Gem for making requests from LBF API}
+  spec.description   = %q{Pile of service objects for making requests to the LBF API and its responses}
+  spec.homepage      = "https://github.com/Oversee/Travel-LBFSoap"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.license       = 'MIT'
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+
+  spec.add_runtime_dependency 'savon', '~> 2.10'
+  spec.add_runtime_dependency 'rubyntlm', '0.3.2'
+  spec.add_runtime_dependency 'activesupport', '~> 4.1'
+
+end

data/lib/lbf/deep_fetch.rb

@@ -0,0 +1,10 @@
+class Hash
+  def deep_fetch(*args)
+    key = args.shift
+    val = self.fetch(key, nil)
+    return val if args.length == 0
+    return nil if val.nil? || !val.respond_to?(:deep_fetch)
+    val.deep_fetch(*args)
+  end
+end
+

data/lib/lbf/lbf_client.rb

@@ -0,0 +1,35 @@
+class LBF::Client
+  attr_reader :username, :password, :url_id, :wsdl, :cart_path
+  def initialize(opts=defaults)
+    options = defaults.merge(opts)
+    %i(username password url_id).each do |key|
+      raise ArgumentError, "Must supply #{key}" unless options.has_key?(key)
+    end
+    @username  = options[:username]
+    @password  = options[:password]
+    @url_id    = options[:url_id]
+    @wsdl      = options[:wsdl]
+  end
+
+  # Searches the LBF API and returns a response object
+  # @param [LBF::Request] The Request object that will be sent to the API
+  # @return [LBF::Response] The appropriate LBF::Response object
+  def search(request=LBF::Request.new)
+    client = Savon.client(pretty_print_xml: true, log_level: :debug,
+                          log: true, wsdl: @wsdl)
+    request.client = self
+    savon_resp = client.call :afs1, xml: request.to_xml
+    response = LBF::Response.new(savon_resp.body)
+    response.errors.map {|e| raise e }
+    response
+  end
+
+  private
+
+  def defaults
+    {
+      wsdl: 'http://webservices.lbftravel.com/services/4.2/ezAirFareService.asmx?WSDL'
+    }
+  end
+
+end

data/lib/lbf/lbf_exceptions.rb

@@ -0,0 +1,2 @@
+class LBF::SearchError < StandardError
+end

data/lib/lbf/lbf_fare.rb

@@ -0,0 +1,18 @@
+# This is fare information for LBF.  Not all keys from the fare_hash are exposed in the object; see below
+# if we need to expand.
+class LBF::Fare
+  def initialize(fare_hash)
+    # {:base=>"1653.9400", :tax_and_fees=>"272.4600", :total=>"1926.4000", :sale_total=>"1926.4000",
+    # :promo_code=>nil, :promo_discount=>"0.0000", :insurance_total=>"0", :markup=>"0",
+    # :tax_and_fees_adult=>"136.2300", :tax_and_fees_child=>"136.2300", :tax_and_fees_infant=>"0",
+    # :fare_type=>"P", :insurance_per_traveler=>"0"}
+    @base                   = BigDecimal.new fare_hash[:base]
+    @taxes_and_fees         = BigDecimal.new fare_hash[:tax_and_fees]
+    @total                  = BigDecimal.new fare_hash[:total]
+    @markup                 = BigDecimal.new fare_hash[:markup]
+    @fare_type              = fare_hash[:fare_type]
+    @discount               = BigDecimal.new fare_hash[:promo_discount]
+    @promo_code             = fare_hash[:promo_code] || 'None'
+    @insurance_per_traveler = BigDecimal.new fare_hash[:insurance_per_traveler]
+  end
+end

data/lib/lbf/lbf_layover.rb

@@ -0,0 +1,11 @@
+class LBF::Layover
+  attr_reader :duration, :airport
+
+  # NB: The :duration method (and corresponding ivar) are in seconds
+  def initialize(segment_hash)
+    @duration = segment_hash[:connection_duration].to_i.minutes
+    @airport  = segment_hash[:dest]
+    @comment  = segment_hash[:connection_comment]
+  end
+end
+

data/lib/lbf/lbf_plane.rb

@@ -0,0 +1,8 @@
+# A simple object representing an airplane.
+class LBF::Plane
+  attr_reader :name, :code
+  def initialize(name, code)
+    @name = name
+    @code = code.to_i
+  end
+end

data/lib/lbf/lbf_quote.rb

@@ -0,0 +1,99 @@
+# Each Quote is a proposal from LBF for the requested trip.  Its trips are the legs of the flight: there will
+# be one trip in :trips if it is a one-way flight, and two if it is a round-trip flight.  Each quote has a
+# pile of IDs that are used to create the appropriate URL string for checkout (which currently doesn't seem
+# to work, but was created according to the API docs).
+#
+# Of particular note are the all_cabins? and nearby_airports? methods.  If all_cabins? is true, then the
+# quote will include at least one segment in a cabin type other than that specified in the LBF::Request.
+# Similarly, if :nearby_airports? is true, then either the origin or destination is not that which was
+# requested, but rather an airport that is nearby.
+#
+# If :offline_only? is true, then we can't display actual inforamtion about the trip.  We can just display
+# the price and a number to call for booking information.
+class LBF::Quote
+  # Has Trip(s) and IDs and Travelers
+  attr_reader :arrival, :departure, :fare, :trips, :travelers, :warnings, :cabin_comments,
+              :id, :group_id, :session_id, :tickets, :seats_remaining
+
+  def initialize(quote_hash)
+    @hash            = quote_hash
+    @arrival         = DateTime.strptime("#{quote_hash[:arr_dt]} #{quote_hash[:arr_tm]}", '%m/%d/%Y %H%M')
+    @departure       = DateTime.strptime("#{quote_hash[:dep_dt]} #{quote_hash[:dep_tm]}", '%m/%d/%Y %H%M')
+    @fare            = LBF::Fare.new quote_hash[:quote_air_fare]
+    @trips           = trips_from(quote_hash.deep_fetch :quote_air_trips, :quote_air_trip)
+    @travelers       = travelers_from(quote_hash.deep_fetch :quote_air_travelers, :quote_air_traveler)
+    @warnings        = warnings_from(quote_hash[:warning])
+    @cabin_comments  = cabin_comments_from(quote_hash[:cabin_comments])
+    @id              = quote_hash[:air_quote_id]
+    @group_id        = quote_hash[:session_air_id]
+    @session_id      = quote_hash[:visit_session_id]
+    @tickets         = quote_hash[:tickets].to_i
+    @seats_remaining = quote_hash[:seats_remaining].to_i
+    @all_cabins      = quote_hash[:cabin_indicator].to_i == 1
+    @international   = !!quote_hash[:international]
+    @nearby_airports = !!quote_hash[:nearby_airport_indicator]
+    @offline_only    = !!quote_hash[:offline_airline_indicator]
+    @tournet         = !!quote_hash[:tournet_indicator]
+  end
+
+  def to_h
+    @hash
+  end
+
+  def query_string
+    "?AirSID=#{group_id}&FARE=#{id}&SesnID=#{session_id}"
+  end
+
+  def tournet?
+    @tournet
+  end
+
+  def all_cabins?
+    @all_cabins
+  end
+
+  def online?
+    !offline_only?
+  end
+
+  def offline_only?
+    @offline_only
+  end
+
+  def international?
+    @international
+  end
+
+  def domestic?
+    !international?
+  end
+
+  private
+
+  def cabin_comments_from(comments_str)
+    return '' if comments_str.nil?
+    comments_str.to_s
+  end
+
+  # The API doc don't specify how this works, so I'm assuming it's the same as the comments field.
+  def warnings_from(warning_str)
+    return '' if warning_str.nil?
+    warning_str.to_s
+  end
+
+  # The appropriate deep_fetch can return either a hash or an array of hashes,
+  # so we have to handle that in this method
+  def trips_from(trip_arr)
+    return [] if trip_arr.nil?
+    trip_arr = [trip_arr].flatten
+    trip_arr.map {|t| LBF::Trip.new(t)}
+  end
+
+  # The appropriate deep_fetch can return either a hash or an array of hashes,
+  # so we have to handle that in this method
+  def travelers_from(trav_arr)
+    return [] if trav_arr.nil?
+    trav_arr = [trav_arr].flatten
+    trav_arr.map {|t| LBF::Traveler.new(t)}
+  end
+end

data/lib/lbf/lbf_request.rb

@@ -0,0 +1,130 @@
+# This class just creates a (very specific) XML document with the appropriate request information to send
+# to the LBF API.
+class LBF::Request
+  AIRPORT_METHODS = %i(origin destination)
+  INT_METHODS = %i(adults children infants)
+  DATE_METHODS = %i(departure_date return_date)
+  OTHER_METHODS = %i(cabin ip)
+  ALL_METHODS = (AIRPORT_METHODS + INT_METHODS + DATE_METHODS + OTHER_METHODS)
+  CABINS = {coach: 'Y', business: 'C', first_class: 'F'}
+
+  attr_reader *ALL_METHODS
+  attr_accessor :client
+
+  AIRPORT_METHODS.each do |meth|
+    define_method("#{meth}=".to_sym) do |arg|
+      raise ArgumentError, "Argument must be a 3-letter airport code" unless arg =~ /[a-zA-Z]{3}/
+      instance_variable_set("@#{meth}", arg.upcase)
+    end
+  end
+
+  INT_METHODS.each do |meth|
+    define_method("#{meth}=".to_sym) do |arg|
+      raise ArgumentError, "Argument must be an Integer" unless arg.is_a?(Integer)
+      instance_variable_set("@#{meth}", arg)
+    end
+  end
+
+  DATE_METHODS.each do |meth|
+    define_method("#{meth}=".to_sym) do |arg|
+      raise ArgumentError, "Date must respond to :strftime" unless arg.respond_to?(:strftime)
+      instance_variable_set("@#{meth}", arg)
+    end
+  end
+
+  def initialize(opts=defaults)
+    %i(origin destination
+       departure_date ip).each { |key| raise ArgumentError, "Must specify :#{key}" unless opts.keys.include? key }
+    options = defaults.merge(opts).select { |k,v| ALL_METHODS.include? k }
+    options.each { |k, v| self.send("#{k}=", v) }
+  end
+
+  def cabin=(symbol)
+    raise ArgumentError, "Cabin must be one of #{CABINS.keys}" unless CABINS.keys.include? symbol
+    @cabin = symbol
+  end
+
+  def ip=(arg)
+    @ip = IPAddr.new("#{arg}")
+  end
+
+  def roundtrip?
+    departure_date.present? && return_date.present?
+  end
+
+  def to_xml
+    <<-XML.strip_heredoc
+    <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+      #{header}
+      #{body}
+    </soap:Envelope>
+    XML
+  end
+
+  private
+
+  def defaults
+    {
+      adults:         1,
+      children:       1,
+      infants:        0,
+      cabin:          :coach
+    }
+  end
+
+  def header
+    <<-HEADER.strip_heredoc
+    <soap:Header>
+      <AuthHeader xmlns="ezgds">
+        <Uname>#{client.username}</Uname>
+        <Pwd>#{client.password}</Pwd>
+        <URL>#{client.url_id}</URL>
+        <VisitSessionID>0</VisitSessionID>
+        <IP>#{ip}</IP>
+      </AuthHeader>
+    </soap:Header>
+    HEADER
+  end
+
+  def body
+    <<-BODY.strip_heredoc
+    <soap:Body>
+      <AFS1 xmlns="ezgds">
+        <ezQuoteAirRequest>
+          <QuoteAirRequestTrips>
+          #{depart_trip_xml}
+          #{return_trip_xml if roundtrip?}
+          </QuoteAirRequestTrips>
+          <PreferredAirline />
+          <Cabin>#{CABINS[cabin]}</Cabin>
+          <Adt>#{adults}</Adt>
+          <Chd>#{children}</Chd>
+          <Inf>#{infants}</Inf>
+          <PromoID>0</PromoID>
+          <CMPCode>0</CMPCode>
+       </ezQuoteAirRequest>
+     </AFS1>
+    </soap:Body>
+    BODY
+  end
+
+  def depart_trip_xml
+    <<-DEPART.strip_heredoc
+     <QuoteAirRequestTrip>
+       <DepDt>#{departure_date.strftime '%m/%d/%Y'}</DepDt>
+       <Orig>#{origin}</Orig>
+       <Dest>#{destination}</Dest>
+     </QuoteAirRequestTrip>
+    DEPART
+  end
+
+  def return_trip_xml
+    <<-RETURN.strip_heredoc
+     <QuoteAirRequestTrip>
+       <DepDt>#{return_date.strftime '%m/%d/%Y'}</DepDt>
+       <Orig>#{destination}</Orig>
+       <Dest>#{origin}</Dest>
+     </QuoteAirRequestTrip>
+    RETURN
+  end
+end

data/lib/lbf/lbf_response.rb

@@ -0,0 +1,33 @@
+# Returned by LBF::Client.search. This object contains an array of LBF::Quotes and an array of
+# LBF::SearchErrors.  :quotes will have a single element if a one-way flight was requeted, and two
+# if a roundtrip flight was requested.
+class LBF::Response
+  attr_reader :quotes, :errors
+  def initialize(hsh)
+    @hash = hsh
+    @errors = errors_from(@hash.deep_fetch :afs1_response, :afs1_result, :quote_air, :error_list)
+    @quotes = quotes_from(@hash.deep_fetch :afs1_response, :afs1_result, :quote_air)
+  end
+
+  def to_h
+    @hash
+  end
+
+  def error?
+    !errors.empty?
+  end
+
+  private
+
+  def errors_from(err_hash)
+    return [] if err_hash.nil?
+    err_hash.values.map { |msg| LBF::SearchError.new(msg) }
+  end
+
+  # Can be a hash or an array of hashes, so we have to handle that
+  def quotes_from(quotes_arr)
+    return [] if quotes_arr.nil?
+    quotes_arr = [quotes_arr].flatten
+    quotes_arr.map { |q| LBF::Quote.new(q) }
+  end
+end

data/lib/lbf/lbf_segment.rb

@@ -0,0 +1,51 @@
+# A segment of an LBF trip.  Since not everything from the incoming segment_hash is exposed, see comment
+# below for segment information
+class LBF::Segment
+  attr_reader :plane, :origin, :destination, :airline, :comments, :arrival, :departure, :flight
+  def initialize(segment_hash)
+    # {
+    # :equipment=>"Canadair Regional Jet 900", :e_ticket=>true, :equipment_code=>"CR9", :flight_stops=>"0",
+    # :airline=>"US", :orig=>"DFW", :duration=>nil, :dest=>"SDF", :airline_name=>"Us Airways",
+    # :flight_operator=>nil, :codeshare_comments=>"MESA AIRLINES AS AMERICAN EAGLE",
+    # :flight_operator_name=>"MESA AIRLINES AS AMERICAN EAGLE", :flight_number=>"5746",
+    # :orig_name=>"Dallas, Fort Worth Intl", :dest_name=>"Louisville,  Louisville Intl",
+    # :arr_dt=>"04/04/2015", :dep_dt=>"04/04/2015", :arr_tm=>"1819", :dep_tm=>"1510", :arr_terminal=>nil,
+    # :dep_terminal=>"B", :connection_duration=>"0",
+    # :seats=>"7", :class_of_service=>"V", :cabin=>"Y",
+    # :cabin_name=>"Economy",
+    # :comments=> {
+    #   :string=>"Operated By MESA AIRLINES AS AMERICAN EAGLE"
+    #   },
+    # :segment_stops=> {
+    #   :quote_air_segment_stop=> {
+    #     :airport=>"DEN",
+    #     :arrive_date=>"4/8/2015",
+    #     :arrive_time=>"1531",
+    #     :depart_date=>"4/8/2015",
+    #     :depart_time=>"1621"
+    #     }
+    #   }
+    # }
+    @plane            = LBF::Plane.new(segment_hash[:equipment], segment_hash[:equipment_code])
+    @e_ticket         = segment_hash[:e_ticket]
+    @stops            = segment_hash[:flight_stops].to_i
+    @origin           = segment_hash[:orig]
+    @destination      = segment_hash[:dest]
+    @airline          = segment_hash[:airline_name]
+    @comments         = comments_from segment_hash[:comments]
+    @arrival          = DateTime.strptime("#{segment_hash[:arr_dt]} #{segment_hash[:arr_tm]}", '%m/%d/%Y %H%M')
+    @departure        = DateTime.strptime("#{segment_hash[:dep_dt]} #{segment_hash[:dep_tm]}", '%m/%d/%Y %H%M')
+    @flight           = segment_hash[:flight_number].to_i
+  end
+
+  def e_ticket?
+    @e_ticket
+  end
+
+  private
+
+  def comments_from(comments_hash)
+    return [] if comments_hash.nil?
+    comments_hash.values
+  end
+end

data/lib/lbf/lbf_traveler.rb

@@ -0,0 +1,10 @@
+# A traveler, according to LBF
+class LBF::Traveler
+  TRAVELER_CATEGORY = LBF::Request::CABINS.invert
+  def initialize(trav_hash)
+    @category       = TRAVELER_CATEGORY[trav_hash[:category].upcase]
+    @fare           = BigDecimal.new trav_hash[:fare]
+    @taxes_and_fees = BigDecimal.new trav_hash[:fare_tax_and_fees]
+    @total_price    = BigDecimal.new trav_hash[:fare_total]
+  end
+end

data/lib/lbf/lbf_trip.rb

@@ -0,0 +1,32 @@
+# A trip, e.g. from LAS to LAX.  Will contain multiple segments if it isn't a non-stop flight.  Also
+# includes layover information.  Segments can have segment stops, for stops that aren't segments. This might
+# mean that the plane stops, but the traveler doesn't get off.  It's not clear from the documentation.
+# Segment stops are not exposed.
+class LBF::Trip
+  attr_reader :duration, :arrival, :departure, :origin, :destination, :notes
+
+  # NB: The :duration method (and corresponding ivar) are in seconds
+  def initialize(trip_hash)
+    @duration    = trip_hash[:duration].to_i.minutes
+    @arrival     = DateTime.strptime("#{trip_hash[:arr_dt]} #{trip_hash[:arr_tm]}", '%m/%d/%Y %H%M')
+    @departure   = DateTime.strptime("#{trip_hash[:dep_dt]} #{trip_hash[:dep_tm]}", '%m/%d/%Y %H%M')
+    @origin      = trip_hash[:orig]
+    @destination = trip_hash[:dest]
+    @notes       = trip_hash[:duration_notes]
+    @segments    = segments_from(trip_hash.deep_fetch :quote_air_segments, :quote_air_segment)
+    @layovers    = layovers_from(trip_hash.deep_fetch :quote_air_segments, :quote_air_segment)
+  end
+
+  private
+
+  def layovers_from(segment_arr)
+    return [] if segment_arr.nil?
+    segment_arr.map { |s| LBF::Layover.new(s) unless s[:connection_duration].to_i == 0 }.compact
+  end
+
+  def segments_from(segment_arr)
+    return [] if segment_arr.nil?
+    segment_arr.map { |s| LBF::Segment.new s }
+  end
+
+end

data/lib/lbf/version.rb

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

data/lib/lbf.rb

@@ -0,0 +1,22 @@
+module LBF
+end
+require 'lbf/version'
+require 'lbf/lbf_client'
+require 'lbf/lbf_request'
+require 'lbf/lbf_response'
+require 'lbf/lbf_exceptions'
+require 'lbf/lbf_quote'
+require 'lbf/lbf_trip'
+require 'lbf/lbf_traveler'
+require 'lbf/lbf_fare'
+require 'lbf/lbf_segment'
+require 'lbf/lbf_plane'
+require 'lbf/lbf_layover'
+require 'lbf/deep_fetch'
+require 'savon'
+require 'pp'
+require 'date'
+require 'active_support/all'
+require 'ipaddr'
+require 'bigdecimal'
+I18n.config.enforce_available_locales = false

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: LBF
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Forrest Fleming
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: savon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: rubyntlm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+description: Pile of service objects for making requests to the LBF API and its responses
+email:
+- ffleming@oversee.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lbf.gemspec
+- lib/lbf.rb
+- lib/lbf/deep_fetch.rb
+- lib/lbf/lbf_client.rb
+- lib/lbf/lbf_exceptions.rb
+- lib/lbf/lbf_fare.rb
+- lib/lbf/lbf_layover.rb
+- lib/lbf/lbf_plane.rb
+- lib/lbf/lbf_quote.rb
+- lib/lbf/lbf_request.rb
+- lib/lbf/lbf_response.rb
+- lib/lbf/lbf_segment.rb
+- lib/lbf/lbf_traveler.rb
+- lib/lbf/lbf_trip.rb
+- lib/lbf/version.rb
+homepage: https://github.com/Oversee/Travel-LBFSoap
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Gem for making requests from LBF API
+test_files: []