branston 0.3.2

data/lib/branston/features/support/paths.rb

@@ -0,0 +1,27 @@
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in webrat_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+    
+    when /the home\s?page/
+      '/'
+    
+    # Add more mappings here.
+    # Here is a more fancy example:
+    #
+    #   when /^(.*)'s profile page$/i
+    #     user_profile_path(User.find_by_login($1))
+
+    else
+      raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+        "Now, go and add a mapping in #{__FILE__}"
+    end
+  end
+end
+
+World(NavigationHelpers)

data/lib/branston/features/support/version_check.rb

@@ -0,0 +1,31 @@
+require 'cucumber/formatter/ansicolor'
+extend Cucumber::Formatter::ANSIColor
+if Cucumber::VERSION != '0.4.4'
+warning = <<-WARNING
+#{red_cukes(15)} 
+
+         #{red_cukes(1)}   R O T T E N   C U C U M B E R   A L E R T    #{red_cukes(1)}
+
+Your #{__FILE__.gsub(/version_check.rb$/, 'env.rb')} file was generated with Cucumber 0.4.4,
+but you seem to be running Cucumber #{Cucumber::VERSION}. If you're running an older 
+version than #{Cucumber::VERSION}, just upgrade your gem. If you're running a newer 
+version than #{Cucumber::VERSION} you should:
+
+  1) Read http://wiki.github.com/aslakhellesoy/cucumber/upgrading
+  
+  2) Regenerate your cucumber environment with the following command:
+
+     ruby script/generate cucumber
+
+If you get prompted to replace a file, hit 'd' to see the difference.
+When you're sure you have captured any personal edits, confirm that you
+want to overwrite #{__FILE__.gsub(/version_check.rb$/, 'env.rb')} by pressing 'y'. Then reapply any
+personal changes that may have been overwritten, preferably in separate files.
+
+This message will then self destruct.
+
+#{red_cukes(15)}
+WARNING
+warn(warning)
+at_exit {warn(warning)}
+end

data/lib/branston/lib/authenticated_system.rb

@@ -0,0 +1,189 @@
+module AuthenticatedSystem
+  protected
+    # Returns true or false if the user is logged in.
+    # Preloads @current_user with the user model if they're logged in.
+    def logged_in?
+      !!current_user
+    end
+
+    # Accesses the current user from the session.
+    # Future calls avoid the database because nil is not equal to false.
+    def current_user
+      @current_user ||= (login_from_session || login_from_basic_auth || login_from_cookie) unless @current_user == false
+    end
+
+    # Store the given user id in the session.
+    def current_user=(new_user)
+      session[:user_id] = new_user ? new_user.id : nil
+      @current_user = new_user || false
+    end
+
+    # Check if the user is authorized
+    #
+    # Override this method in your controllers if you want to restrict access
+    # to only a few actions or if you want to check if the user
+    # has the correct rights.
+    #
+    # Example:
+    #
+    #  # only allow nonbobs
+    #  def authorized?
+    #    current_user.login != "bob"
+    #  end
+    #
+    def authorized?(action = action_name, resource = nil)
+      logged_in?
+    end
+
+    # Filter method to enforce a login requirement.
+    #
+    # To require logins for all actions, use this in your controllers:
+    #
+    #   before_filter :login_required
+    #
+    # To require logins for specific actions, use this in your controllers:
+    #
+    #   before_filter :login_required, :only => [ :edit, :update ]
+    #
+    # To skip this in a subclassed controller:
+    #
+    #   skip_before_filter :login_required
+    #
+    def login_required
+      authorized? || access_denied
+    end
+
+    # Redirect as appropriate when an access request fails.
+    #
+    # The default action is to redirect to the login screen.
+    #
+    # Override this method in your controllers if you want to have special
+    # behavior in case the user is not authorized
+    # to access the requested action.  For example, a popup window might
+    # simply close itself.
+    def access_denied
+      respond_to do |format|
+        format.html do
+          store_location
+          redirect_to new_session_path
+        end
+        # format.any doesn't work in rails version < http://dev.rubyonrails.org/changeset/8987
+        # Add any other API formats here.  (Some browsers, notably IE6, send Accept: */* and trigger 
+        # the 'format.any' block incorrectly. See http://bit.ly/ie6_borken or http://bit.ly/ie6_borken2
+        # for a workaround.)
+        format.any(:json, :xml) do
+          request_http_basic_authentication 'Web Password'
+        end
+      end
+    end
+
+    # Store the URI of the current request in the session.
+    #
+    # We can return to this location by calling #redirect_back_or_default.
+    def store_location
+      session[:return_to] = request.request_uri
+    end
+
+    # Redirect to the URI stored by the most recent store_location call or
+    # to the passed default.  Set an appropriately modified
+    #   after_filter :store_location, :only => [:index, :new, :show, :edit]
+    # for any controller you want to be bounce-backable.
+    def redirect_back_or_default(default)
+      redirect_to(session[:return_to] || default)
+      session[:return_to] = nil
+    end
+
+    # Inclusion hook to make #current_user and #logged_in?
+    # available as ActionView helper methods.
+    def self.included(base)
+      base.send :helper_method, :current_user, :logged_in?, :authorized? if base.respond_to? :helper_method
+    end
+
+    #
+    # Login
+    #
+
+    # Called from #current_user.  First attempt to login by the user id stored in the session.
+    def login_from_session
+      self.current_user = User.find_by_id(session[:user_id]) if session[:user_id]
+    end
+
+    # Called from #current_user.  Now, attempt to login by basic authentication information.
+    def login_from_basic_auth
+      authenticate_with_http_basic do |login, password|
+        self.current_user = User.authenticate(login, password)
+      end
+    end
+    
+    #
+    # Logout
+    #
+
+    # Called from #current_user.  Finaly, attempt to login by an expiring token in the cookie.
+    # for the paranoid: we _should_ be storing user_token = hash(cookie_token, request IP)
+    def login_from_cookie
+      user = cookies[:auth_token] && User.find_by_remember_token(cookies[:auth_token])
+      if user && user.remember_token?
+        self.current_user = user
+        handle_remember_cookie! false # freshen cookie token (keeping date)
+        self.current_user
+      end
+    end
+
+    # This is ususally what you want; resetting the session willy-nilly wreaks
+    # havoc with forgery protection, and is only strictly necessary on login.
+    # However, **all session state variables should be unset here**.
+    def logout_keeping_session!
+      # Kill server-side auth cookie
+      @current_user.forget_me if @current_user.is_a? User
+      @current_user = false     # not logged in, and don't do it for me
+      kill_remember_cookie!     # Kill client-side auth cookie
+      session[:user_id] = nil   # keeps the session but kill our variable
+      # explicitly kill any other session variables you set
+    end
+
+    # The session should only be reset at the tail end of a form POST --
+    # otherwise the request forgery protection fails. It's only really necessary
+    # when you cross quarantine (logged-out to logged-in).
+    def logout_killing_session!
+      logout_keeping_session!
+      reset_session
+    end
+    
+    #
+    # Remember_me Tokens
+    #
+    # Cookies shouldn't be allowed to persist past their freshness date,
+    # and they should be changed at each login
+
+    # Cookies shouldn't be allowed to persist past their freshness date,
+    # and they should be changed at each login
+
+    def valid_remember_cookie?
+      return nil unless @current_user
+      (@current_user.remember_token?) && 
+        (cookies[:auth_token] == @current_user.remember_token)
+    end
+    
+    # Refresh the cookie auth token if it exists, create it otherwise
+    def handle_remember_cookie!(new_cookie_flag)
+      return unless @current_user
+      case
+      when valid_remember_cookie? then @current_user.refresh_token # keeping same expiry date
+      when new_cookie_flag        then @current_user.remember_me 
+      else                             @current_user.forget_me
+      end
+      send_remember_cookie!
+    end
+  
+    def kill_remember_cookie!
+      cookies.delete :auth_token
+    end
+    
+    def send_remember_cookie!
+      cookies[:auth_token] = {
+        :value   => @current_user.remember_token,
+        :expires => @current_user.remember_token_expires_at }
+    end
+
+end

data/lib/branston/lib/authenticated_test_helper.rb

@@ -0,0 +1,11 @@
+module AuthenticatedTestHelper
+  # Sets the current user in the session from the user fixtures.
+  def login_as(user)
+    @request.session[:user_id] = user ? (user.is_a?(User) ? user.id : users(user).id) : nil
+  end
+
+  def authorize_as(user)
+    @request.env["HTTP_AUTHORIZATION"] = user ? ActionController::HttpAuthentication::Basic.encode_credentials(users(user).login, 'monkey') : nil
+  end
+  
+end

data/lib/branston/lib/branston.rb

@@ -0,0 +1,149 @@
+require File.dirname(__FILE__) + '/../lib/client'
+require 'optparse'
+require 'ftools'
+
+BRANSTON_HOME= Dir.pwd + '/.branston'
+PORT = 3970
+
+class Branston
+  
+  attr_accessor :args
+  
+  def initialize(args)
+    self.args = args
+    go()
+  end
+  
+  def go
+    
+    options = {
+      :Port        => PORT,
+      :Host        => "0.0.0.0",
+      :environment => (ENV['RAILS_ENV'] || "production").dup,
+      :detach      => true,
+      :debugger    => false,
+      :path        => nil,
+      :directory   => BRANSTON_HOME
+    }
+    
+    actions = []
+    
+    ARGV.clone.options do |opts|
+      opts.on("-i", "--init", String, "Initialise Branston") {
+        opts.on("-w", "--working=directory", String, "Initialise branston in the given " + 
+          "directory", "Default: .branston") { |v| options[:directory] =v }
+        actions << 'init'
+      }
+      opts.on("-s", "--server", String, "Run a Branston Server") { 
+        opts.on("-p", "--port=port", Integer,
+          "Runs Branston on the specified port.", "Default: #{PORT}") { |v| options[:Port] = v }
+        opts.on("-b", "--binding=ip", String,
+          "Binds Branston to the specified ip.", "Default: 0.0.0.0") { |v| options[:Host] = v }
+        opts.on("-P", "--path=/path", String, "Runs Branston mounted at a specific path.", "Default: /") { |v| options[:path] = v }
+        opts.on("-w", "--working=directory", String, "Run branston in the given " + 
+          "directory, the same directory that you branston --initialised into", "Default: .branston") { |v| options[:directory] =v }
+        opts.on("-fg", "--foreground", String) { |v| options[:foreground] = true }
+        actions << 'server'
+      }
+      opts.on("-g", "--generate", String, "Generate a feature from a Branston Server") { 
+         opts.on("-p", "--port=port", Integer,
+          "Access a branston server on the specified port.", "Default: #{PORT}") { |v| options[:Port] = v }
+        opts.on("-b", "--binding=ip", String,
+          "Access a branston server on the specified ip.", "Default: 0.0.0.0") { |v| options[:Host] = v }
+        opts.on("-f", "--feature=name", String,
+          "Generate a feature for the given story regular expression.") { |v| options[:feature] = v }
+        actions << 'generator'
+      }
+      opts.separator ""
+      opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+      opts.parse!
+      
+      if ARGV.empty? or actions.size != 1
+        puts opts; exit       
+      end
+    end
+    
+    if actions.first == 'server'
+      launch_branston_server(options)
+    elsif actions.first == 'generator'
+      Client.new(options).generate_story_files
+    elsif actions.first == 'init'
+      initialise_branston(options)
+    end
+  end
+  
+  private
+  
+  def initialise_branston(options)
+    File.makedirs options[:directory]
+    unless File.exists? options[:directory] + "/branston.sqlite3"
+      File.copy File.dirname(__FILE__) + "/../db/pristine.sqlite3", 
+      options[:directory] + "/branston.sqlite3"
+    end
+    
+    %w(cache pids sessions sockets).each do |dir_to_make|
+      FileUtils.mkdir_p(File.join(options[:directory], dir_to_make))
+    end
+    
+    puts "Successfully initialised branston in #{options[:directory]}"
+  end
+  
+  def launch_branston_server(options)
+    require 'active_support'
+    require 'action_controller'
+
+    server = Rack::Handler.get(ARGV.first) rescue nil
+    unless server
+      begin
+        server = Rack::Handler::Mongrel
+      rescue LoadError => e
+        server = Rack::Handler::WEBrick
+      end
+    end
+    
+    puts "Branston server starting on http://#{options[:Host]}:#{options[:Port]}#{options[:path]}"
+    
+    unless options[:foreground]
+      Process.daemon
+      pid = options[:directory] + "/pids/server.pid"
+      File.open(pid, 'w'){ |f| f.write(Process.pid) }
+      at_exit { File.delete(pid) if File.exist?(pid) }
+    end
+    
+    ENV["RAILS_ENV"] = options[:environment]
+    RAILS_ENV.replace(options[:environment]) if defined?(RAILS_ENV)
+    
+    require File.dirname(__FILE__) + "/../config/environment"
+    
+    ActiveRecord::Base.establish_connection(
+      :adapter => 'sqlite3',
+      :database =>  options[:directory] + '/branston.sqlite3',
+      :pool => 5,
+      :timeout => 5000
+      )
+    inner_app = ActionController::Dispatcher.new
+    
+    if options[:path].nil?
+      map_path = "/"
+    else
+      ActionController::Base.relative_url_root = options[:path]
+      map_path = options[:path]
+    end
+    
+    app = Rack::Builder.new {    
+      map map_path do
+        use Rails::Rack::Static 
+        run inner_app
+      end
+    }.to_app
+    
+    trap(:INT) { exit }
+    
+    begin
+      server.run(app, options.merge(:AccessLog => []))
+    ensure
+      puts 'Goodbye'
+    end
+  end
+end
+

data/lib/branston/lib/client.rb

@@ -0,0 +1,61 @@
+require 'net/http'
+require "rexml/document"
+require 'ostruct'
+require File.dirname(__FILE__) + '/../lib/story_generator'
+include StoryGenerator
+
+class Client
+  
+  attr_accessor :options
+  
+  def initialize(options)
+    self.options = options
+  end
+  
+  def generate_story_files
+    
+    @xml = get_xml
+    #puts @xml
+    unless @xml.nil?
+      root = @xml.root
+      story = OpenStruct.new
+      story.description = root.elements["/story/description"].text
+      story.title = root.elements["/story/title"].text
+      story.scenarios = []
+      root.elements.each("/story/scenarios/scenario") { |scenario|
+        s = OpenStruct.new
+        s.preconditions = []
+        s.outcomes = []
+        s.title = scenario.elements["title"].text
+        
+        scenario.elements.each("preconditions/precondition") { |precondition|
+          p = OpenStruct.new
+          p.description = precondition.elements["description"].text
+          s.preconditions << p
+        }
+        
+        scenario.elements.each("outcomes/outcome") { |outcome|          
+          o = OpenStruct.new
+          o.description = outcome.elements["description"].text
+          s.outcomes << o
+        }
+        
+        story.scenarios << s
+      }
+      
+      generate(story)
+    end
+  end
+   
+  def get_xml
+    Net::HTTP.start(options[:Host] , options[:Port]) { |http|
+      req = Net::HTTP::Get.new("/stories/#{options[:feature]}.xml")
+      puts "generating /stories/#{options[:feature]}.xml"
+      response = http.request(req)
+      xml = REXML::Document.new response.body
+      return xml
+    }
+  end
+  
+end
+