halffare 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bda0442ac9dab0587de36dde13f84c71f1c45753
+  data.tar.gz: 16e0a906faeda411f7a5b4bd6b57ffc38eae4d2d
+SHA512:
+  metadata.gz: f2c60bf02b70ce2f8d9fcc65f07461bd84f9ff50ae694bb2e6da28625313ed2b1335f312861bef01c5f1c6fa15ff24ef7dab1283453493a1f5b6160289f11373
+  data.tar.gz: 908e0da3000e7155e1c1ce3b7da14ce772a3d4fca00860939667871fc07541607baa71e7761b1b8943c517b84c8eafe0decd8f785cd373a10a99b1e427410ce3

data/README.rdoc

@@ -0,0 +1,38 @@
+= halffare
+--------------------------------------
+This software is in no way affiliated with, authorized, maintained, sponsored or endorsed by sbb.ch or any of its affiliates or subsidiaries.
+--------------------------------------
+
++halffare+ evaluates whether a SBB Half-Fare travelcard is profitable based on your online order history.
+
+Provides commands to download your online order history from sbb.ch and evaluate it.
+
+{<img src="https://raw.githubusercontent.com/rndstr/halffare/master/media/halffare-results.png" alt="halffare evaluation results" />}
+
+
+== Getting started
+
+Install
+
+  $ gem install halffare
+
+Download order history
+
+  $ halffare fetch --months=12 --output=year.halffare
+
+Evaluate orders
+
+  $ halffare stats --input=year.halffare
+
+More options
+
+  $ halffare help
+
+== Usage
+
+:include:halffare.rdoc
+
+== License
+
+{MIT license}[https://github.com/rndstr/halffare/blob/master/LICENSE]
+

data/bin/halffare

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+require 'gli'
+require 'halffare'
+
+include GLI::App
+
+program_desc 'Evaluates whether a SBB Half-Fare travelcard is profitable based on your online order history'
+
+version Halffare::VERSION
+
+desc 'Fetches your order history from sbb.ch and stores them in a file'
+command :fetch do |c|
+  c.desc 'Username for sbb.ch'
+  c.arg_name 'username'
+  c.flag [:u,:username]
+
+  c.desc 'Password for sbb.ch'
+  c.arg_name 'password'
+  c.flag [:p,:password]
+
+  c.desc 'Filename to store the data in'
+  c.default_value 'orders.halffare'
+  c.arg_name 'output'
+  c.flag [:o, :output]
+
+  c.desc 'Number of pages to retrieve'
+  c.default_value 32
+  c.arg_name 'count'
+  c.flag [:pages]
+
+  c.desc 'Stop fetching orders when reaching months back'
+  c.arg_name :months
+  c.flag [:m, :months]
+
+  c.desc 'Overwrite an existing data file'
+  c.switch :force, :negatable => false
+
+  c.desc 'Also print debug output'
+  c.switch :debug, :negatable => false
+
+  c.action do |global_options,options,args|
+    Halffare.debug = options[:debug]
+    if File.exists?(options[:output]) && !options[:force]
+      log_error "file #{options[:output]} exists, use --force or --output"
+    else
+      fetch = Halffare::Fetch.new()
+      fetch.login(options[:username], options[:password])
+      fetch.download(options[:output], options[:pages], options[:months])
+    end
+  end
+end
+
+desc "Calculates and displays stats about your order history"
+command :stats do |c|
+  c.desc 'Filename to read the data from'
+  c.default_value 'orders.halffare'
+  c.arg_name 'input'
+  c.flag [:i, :input]
+
+  c.desc 'Strategy to use for determining price savings [guess, sbb, sbbguess]'
+  c.default_value :sbbguess
+  c.arg_name :strategy
+  c.flag [:s, :strategy]
+#  c.must_match [:sbb, :guess, 'sbbguess']
+
+  c.desc 'Prices found in input file are of type [half, full, ask]'
+  c.default_value :ask
+  c.arg_name :pricetype
+  c.flag [:p, :pricetype]
+#  c.must_match [:half, :full, :ask]
+
+  c.desc 'Restrict how many months in the past to consider orders'
+  c.arg_name :months
+  c.flag [:m, :months]
+
+  c.desc 'Also print debug output'
+  c.switch :debug, :negatable => false
+
+  c.action do |global_options,options,args|
+    Halffare.debug = options[:debug]
+    stats = Halffare::Stats.new
+    stats.read(options[:input], options[:months])
+    if stats.count > 0
+      if options[:pricetype] == :ask
+        options[:pricetype] = yesno('Did you buy your tickets with a half-fare card?', nil) ? 'half' : 'full';
+      end
+      stats.calculate(options[:strategy], options[:pricetype] == 'half')
+      stats.display(options[:pricetype] == 'half')
+    end
+  end
+end
+
+pre do |global,command,options,args|
+  # Pre logic here
+  # Return true to proceed; false to abort and not call the
+  # chosen command
+  # Use skips_pre before a command to skip this block
+  # on that command only
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+  # Use skips_post before a command to skip this
+  # block on that command only
+end
+
+on_error do |exception|
+  p exception
+  p exception.backtrace.join("\n")
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+exit run(ARGV)

data/halffare.rdoc

@@ -0,0 +1,114 @@
+== halffare - Evaluates whether a SBB Half-Fare travelcard is profitable based on your online order history
+
+v0.1.1
+
+=== Global Options
+=== --help
+Show this message
+
+
+
+=== --version
+Display the program version
+
+
+
+=== Commands
+==== Command: <tt>fetch </tt>
+Fetches your order history from sbb.ch and stores them in a file
+
+
+===== Options
+===== -m|--months months
+
+Stop fetching orders when reaching months back
+
+[Default Value] None
+
+
+===== -o|--output output
+
+Filename to store the data in
+
+[Default Value] orders.halffare
+
+
+===== -p|--password password
+
+Password for sbb.ch
+
+[Default Value] None
+
+
+===== --pages count
+
+Number of pages to retrieve
+
+[Default Value] 32
+
+
+===== -u|--username username
+
+Username for sbb.ch
+
+[Default Value] None
+
+
+===== --debug
+Also print debug output
+
+
+
+===== --force
+Overwrite an existing data file
+
+
+
+==== Command: <tt>help  command</tt>
+Shows a list of commands or help for one command
+
+Gets help for the application or its commands. Can also list the commands in a way helpful to creating a bash-style completion function
+===== Options
+===== -c
+List commands one per line, to assist with shell completion
+
+
+
+==== Command: <tt>stats </tt>
+Calculates and displays stats about your order history
+
+
+===== Options
+===== -i|--input input
+
+Filename to read the data from
+
+[Default Value] orders.halffare
+
+
+===== -m|--months months
+
+Restrict how many months in the past to consider orders
+
+[Default Value] None
+
+
+===== -p|--pricetype pricetype
+
+Prices found in input file are of type [half, full, ask]
+
+[Default Value] ask
+
+
+===== -s|--strategy strategy
+
+Strategy to use for determining price savings [guess, sbb, sbbguess]
+
+[Default Value] sbbguess
+
+
+===== --debug
+Also print debug output
+
+
+

data/lib/halffare.rb

@@ -0,0 +1,69 @@
+require 'mechanize'
+require 'highline/import'
+require 'logger'
+require 'date'
+require 'yaml'
+
+require 'halffare/version.rb'
+require 'halffare/fetch.rb'
+require 'halffare/stats.rb'
+require 'halffare/model/order.rb'
+require 'halffare/price.rb'
+require 'halffare/price_base.rb'
+require 'halffare/price_guess.rb'
+require 'halffare/price_sbb.rb'
+
+module Kernel
+  private
+  def currency(cash)
+    'CHF' + sprintf('%.2f', cash.to_f.abs)
+  end
+
+  def log_debug(str)
+    say(str) if Halffare.debug
+  end
+
+  def log_info(str)
+    say("#{str}")
+  end
+
+  def log_notice(str)
+    say("<%= color('#{str.gsub("'","\\\\'")}', BOLD) %>")
+  end
+
+  def log_heading(str)
+    say("<%= color('#{str.gsub("'","\\\\'")}', YELLOW, BOLD) %>")
+  end
+
+  def log_result(str)
+    say("<%= color('#{str.gsub("'","\\\\'")}', GREEN) %>")
+  end
+
+  def log_emphasize(str)
+    say("<%= color('#{str.gsub("'","\\\\'")}', CYAN) %>")
+  end
+
+  def log_error(str)
+    say("<%= color('#{'ERROR: ' + str.gsub("'","\\\\'")}', WHITE, ON_RED, BOLD) %>")
+  end
+
+  def log_order(order)
+    log_info "\n"
+    log_heading "#{order.order_date} #{order.description}"
+    log_emphasize "You paid: #{currency(order.price)}"
+  end
+
+  def yesno(prompt = 'Continue?', default = true)
+    a = ''
+    s = '[y/n]'
+    unless default.nil?
+      s = default  ? '[Y/n]' : '[y/N]'
+    end
+    d = default ? 'y' : 'n'
+    until %w[y n].include? a
+      a = ask("#{prompt} #{s}  ") { |q| q.limit = 1; q.case = :downcase }
+      a = d if a.length == 0
+    end
+    a == 'y'
+  end
+end

data/lib/halffare/fetch.rb

@@ -0,0 +1,112 @@
+module Halffare
+
+  class Fetch
+    USER_AGENT = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11'
+    URL_LOGIN = 'http://www.sbb.ch/meta/login.html'
+    URL_ORDERS = 'https://www.sbb.ch/ticketshop/b2c/dossierListe.do'
+    ORDER_NOTE_FILE_CREATED = 'halffare-orders-file-created'
+
+    def initialize()
+      @agent = ::Mechanize.new
+      @agent.user_agent = USER_AGENT
+    end
+
+    def login(username, password)
+      username = ask("sbb.ch username?  ") unless username
+      password = ask("sbb.ch password?  ") { |q| q.echo = "*" } unless password
+      log_info "logging in..."
+
+      #@agent.log = Logger.new('debug.log')
+
+      @response = @agent.get URL_LOGIN
+
+      login = @response.forms.first
+      login['logon.username'] = username
+      login['logon.password'] = password
+
+      @response = @agent.submit(login)
+    end
+
+    def download(filename, pages, months)
+      @response = @agent.get URL_ORDERS
+
+      logged_in!
+
+      begin
+        left = pages.to_i
+        page = 1
+        stop_after = months ? (Date.today << months.to_i).strftime('%Y-%m-%d') : nil
+
+        log_info "will stop scraping after reaching #{stop_after}" unless stop_after.nil?
+        log_info "writing data to #{filename}"
+
+        file = File.open(filename, "w")
+        oldest_date_on_page = Date.today.strftime
+
+        # fake entry so when evaluating this file the calculation goes up until today
+        # and not to the last order.
+        file.write "#{oldest_date_on_page}|#{oldest_date_on_page}|0|#{ORDER_NOTE_FILE_CREATED}|\n"
+
+        loop do
+          print ">>> page #{page}/#{pages} "
+          orders do |idx, travel_date, order_date, price, note, name|
+            print "."
+
+            travel_date = Date.parse(travel_date).strftime
+            order_date = Date.parse(order_date).strftime
+            oldest_date_on_page = [order_date, oldest_date_on_page].min
+
+            file.write "#{travel_date}|#{order_date}|#{price}|#{note}|#{name}\n" if stop_after.nil? || travel_date >= stop_after
+          end
+          puts
+          next!
+
+          log_debug "oldest order on page was on #{oldest_date_on_page}" if Halffare.debug
+
+          page += 1
+          left -= 1
+
+          break if !stop_after.nil? && oldest_date_on_page < stop_after
+          break if left <= 0
+        end
+      rescue IOError => e
+        puts e
+      ensure
+        file.close unless file == nil
+      end
+    end
+
+    private
+    def orders
+      @response.search('#orders tbody tr').each do |order|
+        idx = order.attr('id').split('-')[1]
+        order_date = order.xpath('./td[1]').text.gsub(/[[:space:]]/, ' ').strip
+        travel_date = order.xpath('./td[2]').text.gsub(/[[:space:]]/, ' ').strip
+        price = order.xpath('./td[4]').text.gsub(/[[:space:]]/, ' ').strip
+        note = order.xpath('./td[5]').text.gsub(/[[:space:]]/, ' ').strip
+
+        description = ""
+        @response.search('#bezeichnungen tr#ordersBezeichnung-' + idx + ' td ul li').each { |i|
+          description << "::" unless description.empty?
+
+          description << i.to_s.gsub(/<br>.*</, '<').gsub(/[[:space:]]/, ' ').gsub(/<.*?>/, '').strip
+        }
+
+        yield idx, order_date, travel_date, price, note, description if block_given?
+      end
+    end
+
+    def next!
+      @response = @response.forms_with(:action => '/ticketshop/b2c/dossierListe.do').first
+      @response = @response.submit(@response.button_with(:name => 'method:more'))
+    end
+
+    def logged_in!
+      error = @response.at '.skinMessageBoxError'
+      if error != nil
+        STDERR.puts "ERROR: Not logged in, verify your username and password"
+        exit 1
+      end
+    end
+  end
+end

data/lib/halffare/model/order.rb

@@ -0,0 +1,16 @@
+module Halffare
+  module Model
+    class Order
+      attr_reader :travel_date, :order_date, :price, :note, :description
+      def initialize(row)
+        from_row(row)
+      end
+
+      def from_row(row)
+        @travel_date, @order_date, @price, @note, @description = row.split("|")
+        @description.strip!
+        @price = @price.to_f
+      end
+    end
+  end
+end

data/lib/halffare/price.rb

@@ -0,0 +1,11 @@
+module Halffare
+  class Price
+    def initialize (strategy)
+      @strategy = strategy
+    end
+
+    def get(order)
+      @strategy.get(order)
+    end
+  end
+end

data/lib/halffare/price_base.rb

@@ -0,0 +1,27 @@
+module Halffare
+  class PriceBase
+
+    # Extracts the prices from an order.
+    #
+    # @param order [Order] The order
+    # @return halfprice, fullprice
+    def get(order)
+      raise 'you need to implement get(order) in your price strategy'
+    end
+
+    def halffare=(hf)
+      @halffare = hf
+    end
+
+    private
+    # Which price has been paid
+    def price_paid
+        @halffare ? 'half' : 'full'
+    end
+
+    # Opposite of {#price_paid}
+    def price_paid_other
+        @halffare ? 'full' : 'half'
+    end
+  end
+end

data/lib/halffare/price_guess.rb

@@ -0,0 +1,14 @@
+module Halffare
+  # Simple guesstimator assuming half-fare card is always half the price
+  # which is probably the case for non-regional tickets
+  class PriceGuess < PriceBase
+    def get(order)
+      price = order.price.to_f
+      if @halffare
+        return price, price*2
+      else
+        return price/2, price
+      end
+    end
+  end
+end

data/lib/halffare/price_sbb.rb

@@ -0,0 +1,102 @@
+# encoding: binary
+module Halffare
+  # More accurate price strategy
+  #
+  # Uses a static table for price conversions, falling back on
+  # guess strategy if no entry found
+  class PriceSbb < PriceGuess
+    alias :price_guess_get :get
+
+    # @param force_guess_fallback [true, false] To use `guess` strategy as fallback instead of asking the user
+    def initialize(force_guess_fallback = false)
+      @force_guess_fallback = force_guess_fallback
+    end
+
+    def get(order)
+      log_debug "looking for an existing rule..."
+      rules.each { |rule|
+        rule.each { |match, definition|
+          if order.description =~ /#{match}/u
+            case
+            when definition['scale'] != nil
+              log_debug "found scale rule: #{definition}"
+              return price_scale(definition, order)
+            when definition['set'] != nil
+              log_debug "found set rule: #{definition}"
+              return price_set(definition, order)
+            when definition['choices'] != nil
+              log_debug "found choices rules: #{definition}"
+              return price_choices(definition, order)
+            end
+          end
+        }
+      }
+      log_result "no satisfying match found" if Halffare.debug
+      return price_guess_get(order) if @force_guess_fallback
+
+      ask_for_price(order)
+    end
+
+    private
+    # Loads rules form the rules file.
+    def rules
+      @rules ||= YAML.load_file(File.expand_path('../pricerules_sbb.yml', __FILE__))
+    end
+
+    # Calculates the prices according to the `scale` definition.
+    def price_scale(definition, order)
+      return definition['scale'][price_paid][0] * order.price, definition['scale'][price_paid][1] * order.price
+    end
+
+    # Calculates the prices according to the `set` definition.
+    def price_set(definition, order)
+      if order.price != definition['set'][price_paid]
+        log_order(order)
+        log_error 'order matched but price differs; ignoring this order.'
+        p order
+        p definition
+        return 0, 0
+      else
+        return definition['set']['half'], definition['set']['full']
+      end
+    end
+
+    # Calculates the prices according to the `choices` definition.
+    def price_choices(definition, order)
+      # auto select
+      definition['choices'].each { |name,prices| return prices['half'], prices['full'] if prices[price_paid] == order.price }
+
+      return price_guess_get(order) if @force_guess_fallback
+
+      choose do |menu|
+        menu.prompt = "\nSelect the choice that applies to your travels?  "
+
+        log_info "\n"
+        definition['choices'].each do |name,prices|
+          menu.choice "#{name} (half-fare: #{currency(prices['half'])}, full: #{currency(prices['full'])})" do
+          end
+        end
+        menu.choice "…or enter manually" do ask_for_price(order) end
+      end
+    end
+
+    # Ask the user for the price.
+    def ask_for_price(order)
+      guesshalf, guessfull = price_guess_get(order)
+
+      if !Halffare.debug
+        # was already logged
+        log_order(order)
+      end
+
+      if @halffare
+        other = ask("What would have been the full price?  ", Float) { |q| q.default = guessfull }
+        return order.price, other
+      else
+        other = ask("What would have been the half-fare price?  ", Float) { |q| q.default = guesshalf }
+        return other, order.price
+      end
+    end
+
+  end
+end

data/lib/halffare/pricerules_sbb.yml

@@ -0,0 +1,16 @@
+- "Gutschrift:Erstattung":
+    scale: {half: [-1,-2], full: [-0.5,-1]}
+- "Individual tickets":
+    scale: {half: [1,2], full: [0.5,1]}
+- "bike pass":
+    scale: {half: [1,1], full: [1,1]}
+- "ZVV Individual ticket/Day Pass city network Zürich \\(Zone 110\\)":
+    set: {half: 5.80, full: 8.40}
+- "Passepartout Individual ticket LUZERN":
+    choices: {
+      "Kurzstrecke 101": {half: 2.40, full: 2.90},
+      "2 Zonen 101": {half: 3.20, full: 4.50}
+      }
+- "Class upgrade \\(route-specific\\)":
+    scale: {half: [1,2], full: [0.5,1]}
+

data/lib/halffare/stats.rb

@@ -0,0 +1,155 @@
+module Halffare
+  class Stats
+
+    # Reads orders from `filename` that date back to max `months` months.
+    #
+    # @param filename [String]       The filename to read from
+    # @param months   [Integer, nil] Number of months look back or nil for all
+    def read(filename, months=nil)
+      @orders = []
+      start = months ? (Date.today << months.to_i).strftime('%Y-%m-%d') : nil
+      file = File.open(filename, "r:UTF-8") do |f|
+        while line = f.gets
+          order = Halffare::Model::Order.new(line)
+          if (start.nil? || line[0,10] >= start) && (order.note != Fetch::ORDER_NOTE_FILE_CREATED)
+            @orders.push(order)
+          end
+        end
+      end
+      log_info "read #{@orders.length} orders from #{filename}"
+      if @orders.length == 0
+        if start.nil?
+          log_notice "no orders found"
+        else
+          log_notice "no orders found after #{start}, maybe tweak the --months param"
+        end
+      end
+    end
+
+    # How many orders were processed.
+    def count
+      @orders.length
+    end
+
+    # Calculates prices according to given strategy.
+    #
+    # @param strategy [String] Strategy name
+    # @param halffare [true, false] True if tickets were bought with a halffare card
+    def calculate(strategy, halffare)
+      @halfprice = 0
+      @fullprice = 0
+
+      if halffare
+        log_info "assuming order prices as half-fare"
+      else
+        log_info "assuming order prices as full"
+      end
+
+      log_notice "please note that you are using a strategy that involves guessing the real price" if ['guess', 'sbbguess'].include? strategy
+
+      strategy = price_factory(strategy)
+      strategy.halffare = halffare
+      log_info "using price strategy: #{strategy.class}"
+      price = Price.new(strategy)
+      log_info "calculating prices..."
+
+      @date_min = false
+      @date_max = false
+      @orders.each do |order|
+
+        if Halffare.debug
+          log_order(order)
+        end
+
+        halfprice, fullprice = price.get(order)
+
+        if Halffare.debug
+          if halfprice != 0 && fullprice != 0
+            log_result "FOUND: #{order.description} (#{order.price}): half=#{currency(halfprice)}, full=#{currency(fullprice)}"
+
+            if halffare
+              log_emphasize "You would pay (full price): #{currency(fullprice)}, you save #{currency(fullprice - order.price)}"
+            else
+              log_emphasize "You would pay (half-fare): #{currency(halfprice)}, you pay #{currency(order.price - halfprice)} more"
+            end
+          end
+        end
+
+        @halfprice += halfprice
+        @fullprice += fullprice
+
+        @date_min = order.travel_date if !@date_min || order.travel_date < @date_min
+        @date_max = order.travel_date if !@date_max || order.travel_date > @date_max
+      end
+    end
+
+    # Load config file.
+    def config
+      @config ||= YAML.load_file(File.expand_path('../../../halffare.yml', __FILE__))
+    end
+
+    def display(halffare)
+      say("\n")
+      days = (Date.parse(@date_max) - Date.parse(@date_min)).to_i
+      paid = halffare ? @halfprice : @fullprice
+      paid_per_day = paid / days
+      fullprice_per_day = @fullprice / days
+      saved_per_day = (@fullprice - @halfprice) / days
+
+      log_info "Results"
+      log_info "======="
+      say("\n")
+      log_info "OVERALL"
+      log_info "orders: #{@orders.length}"
+      log_info "first travel date: #{@date_min}"
+      log_info "last travel date : #{@date_max} (#{days} days)"
+      log_info "half-fare price  : #{currency(@halfprice)}#{halffare ? ' (what you paid)':''}"
+      log_info "full price       : #{currency(@fullprice)}#{halffare ? '' : ' (what you paid)'}"
+      log_info "half-fare savings: #{currency(@fullprice - @halfprice)}"
+      say("\n")
+      log_info "PER DAY"
+      log_info "you pay          : #{currency(paid_per_day)}"
+      log_info "half-fare savings: #{currency(saved_per_day)}"
+
+      say("\n")
+      log_info "Half-Fare Card"
+      log_info "-------------"
+
+      config['cards'].each do |months,cash|
+        say("\n")
+        years = months/12
+        saved = saved_per_day * years * 365
+        log_info "#{years} YEAR#{years == 1 ? '' : 'S'} #{currency(cash)}"
+        log_info "you pay          : #{currency(paid_per_day * years * 365)}"
+        log_info "full price       : #{currency(fullprice_per_day * years * 365)}"
+        log_info "half-fare savings: #{currency(saved)}"
+        if saved >= cash
+          say("<%= color('GOOD TO GO', WHITE, BOLD, ON_GREEN) %> (#{currency((saved - cash) / years)} net win per year)")
+        else
+          say("<%= color('NAY', WHITE, BOLD, ON_RED) %> (#{currency((cash - saved) / years)} net loss per year)")
+        end
+      end
+
+      if fullprice_per_day * 365 > 2500
+        say("\n")
+        log_result "Since your tickets would cost approximately #{currency(fullprice_per_day * 365)} per year (w/o half-fare card) you should check out the GA prices for your age bracket: http://www.sbb.ch/abos-billette/abonnemente/ga/preise.html"
+      end
+    end
+
+    private
+    def price_factory(strategy)
+      case strategy.to_s
+      when "guess"
+        Halffare::PriceGuess.new
+      when "sbb"
+        Halffare::PriceSbb.new
+      when "sbbguess"
+        Halffare::PriceSbb.new(true)
+      else
+        raise "unknown strategy: #{strategy}"
+      end
+    end
+
+  end
+end
+

data/lib/halffare/version.rb

@@ -0,0 +1,11 @@
+module Halffare
+  VERSION = '0.1.1'
+  @@debug = false
+
+  def self.debug=(d)
+    @@debug = d
+  end
+  def self.debug
+    @@debug
+  end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: halffare
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Roland Schilter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-19 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  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'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  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'
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.7.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.7.3
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.21
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.21
+description: Evaluates whether a SBB Half-Fare travelcard is profitable based on your
+  online order history
+email: roli@schilter.me
+executables:
+- halffare
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- halffare.rdoc
+files:
+- bin/halffare
+- lib/halffare/model/order.rb
+- lib/halffare/fetch.rb
+- lib/halffare/price.rb
+- lib/halffare/price_base.rb
+- lib/halffare/price_guess.rb
+- lib/halffare/price_sbb.rb
+- lib/halffare/pricerules_sbb.yml
+- lib/halffare/stats.rb
+- lib/halffare/version.rb
+- lib/halffare.rb
+- README.rdoc
+- halffare.rdoc
+homepage: https://github.com/rndstr/halffare
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --title
+- halffare
+- --main
+- README.rdoc
+- -ri
+require_paths:
+- lib
+- 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.0.5
+signing_key: 
+specification_version: 4
+summary: SBB Half-Fare travelcard profitability
+test_files: []