holoserve 0.3.1 → 0.4.0

data/lib/holoserve/interface/fake.rb

@@ -1,53 +1,61 @@
+require 'goliath/api'
 require 'pp'
 
-class Holoserve::Interface::Fake
+class Holoserve::Interface::Fake < Goliath::API
 
-  def call(env)
-    request = Holoserve::Request::Decomposer.new(env).hash
-    pair = Holoserve::Pair::Finder.new(configuration, request).pair
+  use Goliath::Rack::Params
+
+  def response(env)
+    request = Holoserve::Request::Decomposer.new(env, params).hash
+    pair = Holoserve::Pair::Finder.new(pairs, request).pair
     if pair
-      if name = pair[:name]
-        history << name
-        logger.info "received handled request with name '#{name}'"
-      end
-      response = Holoserve::Response::Combiner.new(pair[:responses], configuration).response
-      if response.empty?
-        logger.warn "received request #{pair[:name]} with undefined response"
-        not_found
-      else
-        Holoserve::Response::Composer.new(response).response_array
-      end
+      id, responses = *pair.values_at(:id, :responses)
+
+      history << id
+      logger.info "received handled request with id '#{id}'"
+
+      selector = Holoserve::Response::Selector.new responses, state, logger
+      default_response, selected_responses = selector.default_response, selector.selected_responses
+
+      update_state default_response, selected_responses
+
+      response = Holoserve::Response::Combiner.new(default_response, selected_responses).response
+      Holoserve::Response::Composer.new(response).response_array
     else
       bucket << request
       logger.error "received unhandled request\n" + request.pretty_inspect
+
       not_found
     end
   end
 
   private
 
-  def not_found
-    [ 404, { "Content-Type" => "text/plain" }, [ "no response found for this request" ] ]
-  end
-
-  def logger
-    Holoserve.instance.logger
+  def update_state(default_response, selected_responses)
+    Holoserve::State::Updater.new(state, default_response[:transitions]).perform
+    (selected_responses || [ ]).each do |response|
+      Holoserve::State::Updater.new(state, response[:transitions]).perform
+    end
   end
 
-  def pairs
-    configuration[:pairs]
+  def not_found
+    [ 404, { :"Content-Type" => "text/plain" }, [ "no response found for this request" ] ]
   end
 
   def bucket
-    configuration[:bucket]
+    config[:bucket] ||= [ ]
   end
 
   def history
-    configuration[:history]
+    config[:history] ||= [ ]
+  end
+
+  def pairs
+    config[:pairs] ||= options[:pairs]
   end
 
-  def configuration
-    Holoserve.instance.configuration
+  def state
+    config[:state] ||= options[:state]
   end
 
 end

data/lib/holoserve/interface.rb

@@ -1,7 +1,23 @@
+require 'goliath/api'
 
-module Holoserve::Interface
+class Holoserve::Interface < Goliath::API
 
   autoload :Control, File.join(File.dirname(__FILE__), "interface", "control")
   autoload :Fake, File.join(File.dirname(__FILE__), "interface", "fake")
 
+  get "/_control/bucket", Control::Bucket::Fetch
+  delete "/_control/bucket", Control::Bucket::Delete
+
+  get "/_control/history", Control::History::Fetch
+  delete "/_control/history", Control::History::Delete
+
+  get "/_control/pairs", Control::Pair::Index
+  get "/_control/pairs/:id", Control::Pair::Fetch
+
+  put "/_control/state", Control::State::Update
+  get "/_control/state", Control::State::Fetch
+  delete "/_control/state", Control::State::Delete
+
+  map "/*", Fake
+
 end

data/lib/holoserve/pair/finder.rb

@@ -1,26 +1,16 @@
 
 class Holoserve::Pair::Finder
 
-  def initialize(configuration, request)
-    @configuration, @request = configuration, request
+  def initialize(pairs, request)
+    @pairs, @request = pairs, request
   end
 
   def pair
-    return nil unless pairs
-    pairs.each do |name, pair|
-      return pair.merge(:name => name) if Holoserve::Request::Matcher.new(@request, pair[:request], fixtures).match?
+    return nil unless @pairs
+    @pairs.each do |id, pair|
+      return pair.merge(:id => id) if Holoserve::Request::Matcher.new(@request, pair[:request]).match?
     end
     nil
   end
 
-  private
-
-  def pairs
-    @configuration[:pairs]
-  end
-
-  def fixtures
-    @configuration[:fixtures]
-  end
-
 end

data/lib/holoserve/pair/loader.rb

@@ -0,0 +1,70 @@
+require 'yaml'
+require 'json'
+
+class Holoserve::Pair::Loader
+
+  def initialize(fixture_file_pattern, pair_file_pattern, logger)
+    @fixtures, @pairs = { }, { }
+    @fixture_file_pattern, @pair_file_pattern = fixture_file_pattern, pair_file_pattern
+    @logger = logger
+  end
+
+  def pairs
+    load_fixtures if @fixture_file_pattern
+    load_pairs if @pair_file_pattern
+    @pairs
+  end
+
+  private
+
+  def load_fixtures
+    Dir[ @fixture_file_pattern ].each do |filename|
+      id = extract_id filename
+      fixture = load_file filename
+      @fixtures[id] = fixture if fixture
+      @logger.info "loaded fixture '#{id}'"
+    end
+    @fixtures.freeze
+  end
+
+  def load_pairs
+    Dir[ @pair_file_pattern ].each do |filename|
+      id = extract_id filename
+      pair = load_file filename
+      @pairs[id] = pair_with_imports pair if pair
+      @logger.info "loaded pair '#{id}'"
+    end
+    @pairs.freeze
+  end
+
+  def extract_id(filename)
+    File.basename filename, ".*"
+  end
+
+  def load_file(filename)
+    format = File.extname(filename).sub(/^\./, "")
+    raise ArgumentError, "file extension indicates wrong format '#{format}' (choose yaml or json)" unless [ "yaml", "json" ].include?(format)
+    data = begin
+        YAML::load_file filename
+      rescue Psych::SyntaxError
+        begin
+          JSON.parse File.read(filename)
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    Holoserve::Tool::Hash::KeySymbolizer.new(data).hash
+  end
+
+  def pair_with_imports(pair)
+    result = {
+      :request => Holoserve::Fixture::Importer.new(pair[:request], @fixtures).result,
+      :responses => { }
+    }
+    (pair[:responses] || { }).each do |id, response|
+      result[:responses][id] = Holoserve::Fixture::Importer.new(response, @fixtures).result
+    end
+    result
+  end
+
+end

data/lib/holoserve/pair.rb

@@ -2,5 +2,6 @@
 module Holoserve::Pair
 
   autoload :Finder, File.join(File.dirname(__FILE__), "pair", "finder")
+  autoload :Loader, File.join(File.dirname(__FILE__), "pair", "loader")
 
 end

data/lib/holoserve/request/decomposer.rb

@@ -1,19 +1,29 @@
 
 class Holoserve::Request::Decomposer
 
-  def initialize(request)
-    @request = request
+  ONLY_HEADERS = [
+    "SERVER_SOFTWARE",
+    "SERVER_NAME",
+    "SERVER_PORT",
+    "REMOTE_ADDR",
+    "SCRIPT_NAME",
+    "CONTENT_TYPE"
+  ].freeze unless defined?(ONLY_HEADERS)
+
+  def initialize(request, parameters)
+    @request, @parameters = request, parameters
   end
 
   def hash
     hash = {
       :method => @request["REQUEST_METHOD"],
-      :path => @request["PATH_INFO"]
+      :path => @request["REQUEST_PATH"]
     }
-    hash.merge! :headers => headers unless headers.empty?
-    hash.merge! :body => body unless body.nil?
-    hash.merge! :parameters => parameters unless parameters.empty?
-    hash.merge! :oauth => oauth unless oauth.empty?
+    hash[:headers] = headers unless headers.empty?
+    hash[:body] = body unless body.nil?
+    hash[:parameters] = parameters unless parameters.empty?
+    hash[:oauth] = oauth unless oauth.empty?
+    hash[:json] = json unless json.empty?
     hash
   end
 
@@ -22,7 +32,7 @@ class Holoserve::Request::Decomposer
   def headers
     headers = { }
     @request.each do |key, value|
-      headers[ key.to_sym ] = value unless key =~ /^rack\./
+      headers[ key.to_sym ] = value if ONLY_HEADERS.include?(key) || key =~ /^HTTP_/
     end
     headers
   end
@@ -35,15 +45,7 @@ class Holoserve::Request::Decomposer
   end
 
   def parameters
-    Holoserve::Tool::Hash::KeySymbolizer.new(query_hash.merge(form_hash)).hash
-  end
-
-  def query_hash
-    @request["rack.request.query_hash"] || { }
-  end
-
-  def form_hash
-    @request["rack.request.form_hash"] || { }
+    Holoserve::Tool::Hash::KeySymbolizer.new(@parameters).hash
   end
 
   def oauth
@@ -62,4 +64,12 @@ class Holoserve::Request::Decomposer
     end
   end
 
+  def json
+    @json ||= if @request["CONTENT_TYPE"] == "application/json"
+      Holoserve::Tool::Hash::KeySymbolizer.new(JSON.parse(@body)).hash
+    else
+      { }
+    end
+  end
+
 end

data/lib/holoserve/request/matcher.rb

@@ -1,9 +1,8 @@
 
 class Holoserve::Request::Matcher
 
-  def initialize(request, request_subset, fixtures)
-    @request = request
-    @request_subset = Holoserve::Fixture::Importer.new(request_subset, fixtures).result
+  def initialize(request, request_subset)
+    @request, @request_subset = request, request_subset
   end
 
   def match?
@@ -12,7 +11,8 @@ class Holoserve::Request::Matcher
       match_headers? &&
       match_body? &&
       match_parameters? &&
-      match_oauth?
+      match_oauth? &&
+      match_json?
   end
 
   private
@@ -59,4 +59,16 @@ class Holoserve::Request::Matcher
     match
   end
 
+  def match_json?
+    match_hash? :json
+  end
+
+  def match_hash?(hash_key)
+    match = true
+    (@request_subset[hash_key] || { }).each do |key, value|
+      match &&= @request[hash_key].is_a?(Hash) && (@request[hash_key][key] == value)
+    end
+    match
+  end
+
 end

data/lib/holoserve/response/combiner.rb

@@ -1,34 +1,14 @@
 
 class Holoserve::Response::Combiner
 
-  def initialize(responses, configuration)
-    @responses, @configuration = responses, configuration
+  def initialize(default, responses)
+    @default, @responses = default, responses
   end
 
   def response
-    Holoserve::Tool::Merger.new(default_response, situation_response).result
-  end
-
-  private
-
-  def default_response
-    @responses[:default] ?
-      Holoserve::Fixture::Importer.new(@responses[:default], fixtures).result :
-      { }
-  end
-
-  def situation_response
-    situation && @responses[situation.to_sym] ?
-      Holoserve::Fixture::Importer.new(@responses[situation.to_sym], fixtures).result :
-      { }
-  end
-  
-  def fixtures
-    @configuration[:fixtures]
-  end
-
-  def situation
-    @configuration[:situation]
+    @responses.inject @default do |result, response|
+      Holoserve::Tool::Merger.new(result, response).result
+    end
   end
 
 end

data/lib/holoserve/response/selector.rb

@@ -0,0 +1,43 @@
+
+class Holoserve::Response::Selector
+
+  class Sandbox
+
+    def initialize(state)
+      state.each do |resource, value|
+        define_singleton_method resource.to_sym do
+          value ? value.to_sym : nil
+        end
+      end
+    end
+
+  end
+
+  def initialize(responses, state, logger)
+    @responses, @logger = responses, logger
+    @sandbox = Sandbox.new state
+  end
+
+  def default_response
+    @responses[:default] ?
+      @responses[:default] :
+      { }
+  end
+
+  def selected_responses
+    result = [ ]
+    (@responses || { }).each do |line, response|
+      next if line.to_s == "default"
+      begin
+        match = @sandbox.instance_eval do
+          eval line.to_s
+        end
+        result << response if match
+      rescue Object => error
+        @logger.error error.inspect
+      end
+    end
+    result
+  end
+
+end

data/lib/holoserve/response.rb

@@ -3,5 +3,6 @@ module Holoserve::Response
 
   autoload :Combiner, File.join(File.dirname(__FILE__), "response", "combiner")
   autoload :Composer, File.join(File.dirname(__FILE__), "response", "composer")
+  autoload :Selector, File.join(File.dirname(__FILE__), "response", "selector")
 
 end

data/lib/holoserve/state/updater.rb

@@ -0,0 +1,14 @@
+
+class Holoserve::State::Updater
+
+  def initialize(state, transitions)
+    @state, @transitions = state, transitions
+  end
+
+  def perform
+    (@transitions || { }).each do |resource, value|
+      @state[resource] = value
+    end
+  end
+
+end

data/lib/holoserve/state.rb

@@ -0,0 +1,6 @@
+
+module Holoserve::State
+
+  autoload :Updater, File.join(File.dirname(__FILE__), "state", "updater")
+
+end

data/lib/holoserve/tool/data_path.rb

@@ -4,10 +4,14 @@ class Holoserve::Tool::DataPath
   PATH_SEPARATOR = ".".freeze unless defined?(PATH_SEPARATOR)
 
   attr_accessor :path
-  attr_accessor :data
+  attr_reader :data
 
   def initialize(path, data)
-    @path, @data = path, data
+    self.path, self.data = path, data
+  end
+
+  def data=(value)
+    @data = Holoserve::Tool::Hash::KeySymbolizer.new(value).hash
   end
 
   def fetch

data/lib/holoserve.rb

@@ -1,4 +1,4 @@
-require 'rack/builder'
+require 'goliath/runner'
 require 'logger'
 
 class Holoserve
@@ -8,44 +8,85 @@ class Holoserve
   autoload :Pair, File.join(File.dirname(__FILE__), "holoserve", "pair")
   autoload :Request, File.join(File.dirname(__FILE__), "holoserve", "request")
   autoload :Response, File.join(File.dirname(__FILE__), "holoserve", "response")
-  autoload :Runner, File.join(File.dirname(__FILE__), "holoserve", "runner")
+  autoload :State, File.join(File.dirname(__FILE__), "holoserve", "state")
   autoload :Tool, File.join(File.dirname(__FILE__), "holoserve", "tool")
 
-  attr_reader :logger
-  attr_reader :configuration
-  attr_reader :rack
+  def initialize(options = { })
+    @port = options[:port] || 4250
+    @pid_filename = options[:pid_filename] || File.expand_path(File.join(File.dirname(__FILE__), "..", "holoserve.pid"))
+    @log_filename = options[:log_filename] || File.expand_path(File.join(File.dirname(__FILE__), "..", "holoserve.log"))
+    @fixture_file_pattern = options[:fixture_file_pattern]
+    @pair_file_pattern = options[:pair_file_pattern]
+    @state = options[:state] || { }
+  end
+
+  def start
+    initialize_logger
+    load_pairs
+    run_goliath true
+    wait_until_running
+  end
 
-  def initialize
+  def run
     initialize_logger
-    initialize_configuration
-    initialize_rack
+    load_pairs
+    run_goliath false
+  end
+
+  def stop
+    kill_goliath
+  end
+
+  def running?
+    !!(process_id && Process.kill(0, process_id) == 1)
+  rescue Errno::ESRCH
+    false
+  end
+
+  def process_id
+    File.read(@pid_filename).to_i
+  rescue Errno::ENOENT
+    nil
   end
 
   private
 
   def initialize_logger
-    @logger = Logger.new STDOUT
+    @logger = Logger.new @log_filename
   end
 
-  def initialize_configuration
-    @configuration = {
-      :pairs => { },
-      :fixtures => { },
-      :situation => nil,
-      :bucket => [ ],
-      :history => [ ]
-    }
+  def load_pairs
+    @pairs = Pair::Loader.new(@fixture_file_pattern, @pair_file_pattern, @logger).pairs
   end
 
-  def initialize_rack
-    @rack = Rack::Builder.new do
-      use Interface::Control
-      run Interface::Fake.new
-    end
+  def run_goliath(daemonize)
+    saved_directory = Dir.pwd
+
+    runner = Goliath::Runner.new [
+      "-P", @pid_filename,
+      "-l", @log_filename,
+      "-e", "production",
+      "-p", @port.to_s,
+      daemonize ? "-d" : "-s"
+    ], nil
+    runner.options[:pairs] = @pairs
+    runner.options[:state] = @state
+    runner.api = Interface.new
+    runner.app = Goliath::Rack::Builder.build Interface, runner.api
+    runner.run
+
+    Dir.chdir saved_directory
+  end
+
+  def wait_until_running
+    sleep 0.2 while !self.running?
   end
 
-  def self.instance
-    @instance ||= self.new
+  def kill_goliath
+    if File.exists?(@pid_filename)
+      system "kill -s QUIT `cat #{@pid_filename}`"
+      File.delete @pid_filename
+    end
   end
 
 end

data/spec/lib/holoserve/fixture/importer_spec.rb

@@ -25,9 +25,10 @@ describe Holoserve::Fixture::Importer do
       subject.hash = {
         :imports => [
           { :path => "one" }
-        ]
+        ],
+        :test => "value"
       }
-      subject.result.should == { :first => 1, :second => 2 }
+      subject.result.should == { :first => 1, :second => 2, :test => "value" }
     end
 
     it "should return a hash with imported fixtures at a target path" do
@@ -77,6 +78,20 @@ describe Holoserve::Fixture::Importer do
       subject.result.should == { :first => 1, :second => 2, :third => 4 }
     end
 
+    it "should return a hash where all the imports (with and without an :as statement) are properly merged together" do
+      subject.hash = {
+        :imports => [
+          { :path => "one" },
+          { :path => "three", :as => "test" },
+          { :path => "two", :as => "test.another" }
+        ],
+        :test => {
+          :fifth => 6
+        }
+      }
+      subject.result.should == { :first => 1, :second => 2, :test => { :third => 4, :another => 3, :fifth => 6 } }
+    end
+
     it "should return a hash where the data is merged with the imports" do
       subject.hash = {
         :imports => [

data/spec/lib/holoserve/tool/data_path_spec.rb

@@ -18,6 +18,12 @@ describe Holoserve::Tool::DataPath do
       subject.fetch.should == "value"
     end
 
+    it "should return the value even if string keys are used" do
+      subject.path = "test"
+      subject.data = { "test" => "value" }.freeze
+      subject.fetch.should == "value"
+    end
+
     it "should return the nested value specified by the given path" do
       subject.path = "test.nested"
       subject.data = { :test => { :nested => "value" }.freeze }.freeze

data/spec/lib/holoserve_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper"))
+
+describe Holoserve do
+
+  subject { described_class.new }
+
+  describe "#start" do
+
+    after :each do
+      subject.stop
+    end
+
+    it "should not change the working directory" do
+      lambda do
+        subject.start
+      end.should_not change(Dir, :pwd)
+    end
+
+    it "should start holoserve" do
+      lambda do
+        subject.start
+      end.should change(subject, :running?).from(false).to(true)
+    end
+
+  end
+
+  describe "#stop" do
+
+    before :each do
+      subject.start
+    end
+
+    after :each do
+      subject.stop
+    end
+
+    it "should stop holoserve" do
+      lambda do
+        subject.stop
+      end.should change(subject, :running?).from(true).to(false)
+    end
+
+  end
+
+end