diff --git a/lib/puppet/indirector/request.rb b/lib/puppet/indirector/request.rb
index 1918a3fb5..fd8d654dd 100644
--- a/lib/puppet/indirector/request.rb
+++ b/lib/puppet/indirector/request.rb
@@ -1,246 +1,199 @@
 require 'cgi'
 require 'uri'
 require 'puppet/indirector'
 
 # This class encapsulates all of the information you need to make an
 # Indirection call, and as a a result also handles REST calls.  It's somewhat
 # analogous to an HTTP Request object, except tuned for our Indirector.
 class Puppet::Indirector::Request
   attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
 
   attr_accessor :server, :port, :uri, :protocol
 
   attr_reader :indirection_name
 
   OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
 
-  def self.from_pson(json)
-    raise ArgumentError, "No indirection name provided in json data" unless indirection_name = json['type']
-    raise ArgumentError, "No method name provided in json data" unless method = json['method']
-    raise ArgumentError, "No key provided in json data" unless key = json['key']
-
-    request = new(indirection_name, method, key, json['attributes'])
-
-    if instance = json['instance']
-      klass = Puppet::Indirector::Indirection.instance(request.indirection_name).model
-      if instance.is_a?(klass)
-        request.instance = instance
-      else
-        request.instance = klass.from_pson(instance)
-      end
-    end
-
-    request
-  end
-
-  def to_pson(*args)
-    result = {
-      'document_type' => 'Puppet::Indirector::Request',
-      'data' => {
-        'type' => indirection_name,
-        'method' => method,
-        'key' => key
-      }
-    }
-    data = result['data']
-    attributes = {}
-    OPTION_ATTRIBUTES.each do |key|
-      next unless value = send(key)
-      attributes[key] = value
-    end
-
-    options.each do |opt, value|
-      attributes[opt] = value
-    end
-
-    data['attributes'] = attributes unless attributes.empty?
-    data['instance'] = instance if instance
-
-    result.to_pson(*args)
-  end
-
   # Is this an authenticated request?
   def authenticated?
     # Double negative, so we just get true or false
     ! ! authenticated
   end
 
   def environment
     @environment ||= Puppet::Node::Environment.new
   end
 
   def environment=(env)
     @environment = if env.is_a?(Puppet::Node::Environment)
       env
     else
       Puppet::Node::Environment.new(env)
     end
   end
 
   def escaped_key
     URI.escape(key)
   end
 
   # LAK:NOTE This is a messy interface to the cache, and it's only
   # used by the Configurer class.  I decided it was better to implement
   # it now and refactor later, when we have a better design, than
   # to spend another month coming up with a design now that might
   # not be any better.
   def ignore_cache?
     ignore_cache
   end
 
   def ignore_terminus?
     ignore_terminus
   end
 
   def initialize(indirection_name, method, key_or_instance, options_or_instance = {})
     if options_or_instance.is_a? Hash
       options = options_or_instance
       @instance = nil
     else
       options  = {}
       @instance = options_or_instance
     end
 
     self.indirection_name = indirection_name
     self.method = method
 
-    options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
-
     set_attributes(options)
 
-    @options = options
+    @options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
 
     if key_or_instance.is_a?(String) || key_or_instance.is_a?(Symbol)
       key = key_or_instance
     else
       @instance ||= key_or_instance
     end
 
     if key
       # If the request key is a URI, then we need to treat it specially,
       # because it rewrites the key.  We could otherwise strip server/port/etc
       # info out in the REST class, but it seemed bad design for the REST
       # class to rewrite the key.
       if key.to_s =~ /^\w+:\/\// # it's a URI
         set_uri_key(key)
       else
         @key = key
       end
     end
 
     @key = @instance.name if ! @key and @instance
   end
 
   # Look up the indirection based on the name provided.
   def indirection
     Puppet::Indirector::Indirection.instance(indirection_name)
   end
 
   def indirection_name=(name)
     @indirection_name = name.to_sym
   end
 
 
   def model
     raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless i = indirection
     i.model
   end
 
   # Should we allow use of the cached object?
   def use_cache?
     if defined?(@use_cache)
       ! ! use_cache
     else
       true
     end
   end
 
   # Are we trying to interact with multiple resources, or just one?
   def plural?
     method == :search
   end
 
   # Create the query string, if options are present.
   def query_string
     return "" unless options and ! options.empty?
     "?" + options.collect do |key, value|
       case value
       when nil; next
       when true, false; value = value.to_s
       when Fixnum, Bignum, Float; value = value # nothing
       when String; value = CGI.escape(value)
       when Symbol; value = CGI.escape(value.to_s)
       when Array; value = CGI.escape(YAML.dump(value))
       else
         raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
       end
 
       "#{key}=#{value}"
     end.join("&")
   end
 
   def to_hash
     result = options.dup
 
     OPTION_ATTRIBUTES.each do |attribute|
       if value = send(attribute)
         result[attribute] = value
       end
     end
     result
   end
 
   def to_s
     return(uri ? uri : "/#{indirection_name}/#{key}")
   end
 
   private
 
   def set_attributes(options)
     OPTION_ATTRIBUTES.each do |attribute|
-      if options.include?(attribute.to_sym)
+      if options.include?(attribute)
         send(attribute.to_s + "=", options[attribute])
         options.delete(attribute)
       end
     end
   end
 
   # Parse the key as a URI, setting attributes appropriately.
   def set_uri_key(key)
     @uri = key
     begin
       uri = URI.parse(URI.escape(key))
     rescue => detail
       raise ArgumentError, "Could not understand URL #{key}: #{detail}"
     end
 
     # Just short-circuit these to full paths
     if uri.scheme == "file"
       @key = URI.unescape(uri.path)
       return
     end
 
     @server = uri.host if uri.host
 
     # If the URI class can look up the scheme, it will provide a port,
     # otherwise it will default to '0'.
     if uri.port.to_i == 0 and uri.scheme == "puppet"
       @port = Puppet.settings[:masterport].to_i
     else
       @port = uri.port.to_i
     end
 
     @protocol = uri.scheme
 
     if uri.scheme == 'puppet'
       @key = URI.unescape(uri.path.sub(/^\//, ''))
       return
     end
 
     env, indirector, @key = URI.unescape(uri.path.sub(/^\//, '')).split('/',3)
     @key ||= ''
     self.environment = env unless env == ''
   end
 end
diff --git a/spec/unit/indirector/request_spec.rb b/spec/unit/indirector/request_spec.rb
index ba7dc815e..87b9af438 100755
--- a/spec/unit/indirector/request_spec.rb
+++ b/spec/unit/indirector/request_spec.rb
@@ -1,399 +1,304 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet/indirector/request'
 
 describe Puppet::Indirector::Request do
   describe "when initializing" do
     it "should require an indirection name, a key, and a method" do
       lambda { Puppet::Indirector::Request.new }.should raise_error(ArgumentError)
     end
 
     it "should always convert the indirection name to a symbol" do
       Puppet::Indirector::Request.new("ind", :method, "mykey").indirection_name.should == :ind
     end
 
     it "should use provided value as the key if it is a string" do
       Puppet::Indirector::Request.new(:ind, :method, "mykey").key.should == "mykey"
     end
 
     it "should use provided value as the key if it is a symbol" do
       Puppet::Indirector::Request.new(:ind, :method, :mykey).key.should == :mykey
     end
 
     it "should use the name of the provided instance as its key if an instance is provided as the key instead of a string" do
       instance = mock 'instance', :name => "mykey"
       request = Puppet::Indirector::Request.new(:ind, :method, instance)
       request.key.should == "mykey"
       request.instance.should equal(instance)
     end
 
     it "should support options specified as a hash" do
       lambda { Puppet::Indirector::Request.new(:ind, :method, :key, :one => :two) }.should_not raise_error(ArgumentError)
     end
 
     it "should support nil options" do
       lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.should_not raise_error(ArgumentError)
     end
 
     it "should support unspecified options" do
       lambda { Puppet::Indirector::Request.new(:ind, :method, :key) }.should_not raise_error(ArgumentError)
     end
 
     it "should use an empty options hash if nil was provided" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).options.should == {}
     end
 
     it "should default to a nil node" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).node.should be_nil
     end
 
     it "should set its node attribute if provided in the options" do
       Puppet::Indirector::Request.new(:ind, :method, :key, :node => "foo.com").node.should == "foo.com"
     end
 
     it "should default to a nil ip" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).ip.should be_nil
     end
 
     it "should set its ip attribute if provided in the options" do
       Puppet::Indirector::Request.new(:ind, :method, :key, :ip => "192.168.0.1").ip.should == "192.168.0.1"
     end
 
     it "should default to being unauthenticated" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_authenticated
     end
 
     it "should set be marked authenticated if configured in the options" do
       Puppet::Indirector::Request.new(:ind, :method, :key, :authenticated => "eh").should be_authenticated
     end
 
     it "should keep its options as a hash even if a node is specified" do
       Puppet::Indirector::Request.new(:ind, :method, :key, :node => "eh").options.should be_instance_of(Hash)
     end
 
     it "should keep its options as a hash even if another option is specified" do
       Puppet::Indirector::Request.new(:ind, :method, :key, :foo => "bar").options.should be_instance_of(Hash)
     end
 
     it "should treat options other than :ip, :node, and :authenticated as options rather than attributes" do
       Puppet::Indirector::Request.new(:ind, :method, :key, :server => "bar").options[:server].should == "bar"
     end
 
     it "should normalize options to use symbols as keys" do
       Puppet::Indirector::Request.new(:ind, :method, :key, "foo" => "bar").options[:foo].should == "bar"
     end
 
     describe "and the request key is a URI" do
       describe "and the URI is a 'file' URI" do
         before do
           @request = Puppet::Indirector::Request.new(:ind, :method, "file:///my/file with spaces")
         end
 
         it "should set the request key to the unescaped full file path" do
           @request.key.should == "/my/file with spaces"
         end
 
         it "should not set the protocol" do
           @request.protocol.should be_nil
         end
 
         it "should not set the port" do
           @request.port.should be_nil
         end
 
         it "should not set the server" do
           @request.server.should be_nil
         end
       end
 
       it "should set the protocol to the URI scheme" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").protocol.should == "http"
       end
 
       it "should set the server if a server is provided" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").server.should == "host"
       end
 
       it "should set the server and port if both are provided" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host:543/stuff").port.should == 543
       end
 
       it "should default to the masterport if the URI scheme is 'puppet'" do
         Puppet.settings.expects(:value).with(:masterport).returns "321"
         Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff").port.should == 321
       end
 
       it "should use the provided port if the URI scheme is not 'puppet'" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").port.should == 80
       end
 
       it "should set the request key to the unescaped key part path from the URI" do
         Puppet::Indirector::Request.new(:ind, :method, "http://host/environment/terminus/stuff with spaces").key.should == "stuff with spaces"
       end
 
       it "should set the :uri attribute to the full URI" do
         Puppet::Indirector::Request.new(:ind, :method, "http:///stuff").uri.should == "http:///stuff"
       end
     end
 
     it "should allow indication that it should not read a cached instance" do
       Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_cache => true).should be_ignore_cache
     end
 
     it "should default to not ignoring the cache" do
       Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_cache
     end
 
     it "should allow indication that it should not not read an instance from the terminus" do
       Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_terminus => true).should be_ignore_terminus
     end
 
     it "should default to not ignoring the terminus" do
       Puppet::Indirector::Request.new(:ind, :method, :key).should_not be_ignore_terminus
     end
   end
 
   it "should look use the Indirection class to return the appropriate indirection" do
     ind = mock 'indirection'
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
     request = Puppet::Indirector::Request.new(:myind, :method, :key)
 
     request.indirection.should equal(ind)
   end
 
   it "should use its indirection to look up the appropriate model" do
     ind = mock 'indirection'
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
     request = Puppet::Indirector::Request.new(:myind, :method, :key)
 
     ind.expects(:model).returns "mymodel"
 
     request.model.should == "mymodel"
   end
 
   it "should fail intelligently when asked to find a model but the indirection cannot be found" do
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
     request = Puppet::Indirector::Request.new(:myind, :method, :key)
 
     lambda { request.model }.should raise_error(ArgumentError)
   end
 
   it "should have a method for determining if the request is plural or singular" do
     Puppet::Indirector::Request.new(:myind, :method, :key).should respond_to(:plural?)
   end
 
   it "should be considered plural if the method is 'search'" do
     Puppet::Indirector::Request.new(:myind, :search, :key).should be_plural
   end
 
   it "should not be considered plural if the method is not 'search'" do
     Puppet::Indirector::Request.new(:myind, :find, :key).should_not be_plural
   end
 
   it "should use its uri, if it has one, as its string representation" do
     Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz").to_s.should == "foo://bar/baz"
   end
 
   it "should use its indirection name and key, if it has no uri, as its string representation" do
     Puppet::Indirector::Request.new(:myind, :find, "key") == "/myind/key"
   end
 
   it "should be able to return the URI-escaped key" do
     Puppet::Indirector::Request.new(:myind, :find, "my key").escaped_key.should == URI.escape("my key")
   end
 
   it "should have an environment accessor" do
     Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").should respond_to(:environment)
   end
 
   it "should set its environment to an environment instance when a string is specified as its environment" do
     Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").environment.should == Puppet::Node::Environment.new("foo")
   end
 
   it "should use any passed in environment instances as its environment" do
     env = Puppet::Node::Environment.new("foo")
     Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => env).environment.should equal(env)
   end
 
   it "should use the default environment when none is provided" do
     Puppet::Indirector::Request.new(:myind, :find, "my key" ).environment.should equal(Puppet::Node::Environment.new)
   end
 
   it "should support converting its options to a hash" do
     Puppet::Indirector::Request.new(:myind, :find, "my key" ).should respond_to(:to_hash)
   end
 
   it "should include all of its attributes when its options are converted to a hash" do
     Puppet::Indirector::Request.new(:myind, :find, "my key", :node => 'foo').to_hash[:node].should == 'foo'
   end
 
   describe "when building a query string from its options" do
     before do
       @request = Puppet::Indirector::Request.new(:myind, :find, "my key")
     end
 
     it "should return an empty query string if there are no options" do
       @request.stubs(:options).returns nil
       @request.query_string.should == ""
     end
 
     it "should return an empty query string if the options are empty" do
       @request.stubs(:options).returns({})
       @request.query_string.should == ""
     end
 
     it "should prefix the query string with '?'" do
       @request.stubs(:options).returns(:one => "two")
       @request.query_string.should =~ /^\?/
     end
 
     it "should include all options in the query string, separated by '&'" do
       @request.stubs(:options).returns(:one => "two", :three => "four")
       @request.query_string.sub(/^\?/, '').split("&").sort.should == %w{one=two three=four}.sort
     end
 
     it "should ignore nil options" do
       @request.stubs(:options).returns(:one => "two", :three => nil)
       @request.query_string.should_not be_include("three")
     end
 
     it "should convert 'true' option values into strings" do
       @request.stubs(:options).returns(:one => true)
       @request.query_string.should == "?one=true"
     end
 
     it "should convert 'false' option values into strings" do
       @request.stubs(:options).returns(:one => false)
       @request.query_string.should == "?one=false"
     end
 
     it "should convert to a string all option values that are integers" do
       @request.stubs(:options).returns(:one => 50)
       @request.query_string.should == "?one=50"
     end
 
     it "should convert to a string all option values that are floating point numbers" do
       @request.stubs(:options).returns(:one => 1.2)
       @request.query_string.should == "?one=1.2"
     end
 
     it "should CGI-escape all option values that are strings" do
       escaping = CGI.escape("one two")
       @request.stubs(:options).returns(:one => "one two")
       @request.query_string.should == "?one=#{escaping}"
     end
 
     it "should YAML-dump and CGI-escape arrays" do
       escaping = CGI.escape(YAML.dump(%w{one two}))
       @request.stubs(:options).returns(:one => %w{one two})
       @request.query_string.should == "?one=#{escaping}"
     end
 
     it "should convert to a string and CGI-escape all option values that are symbols" do
       escaping = CGI.escape("sym bol")
       @request.stubs(:options).returns(:one => :"sym bol")
       @request.query_string.should == "?one=#{escaping}"
     end
 
     it "should fail if options other than booleans or strings are provided" do
       @request.stubs(:options).returns(:one => {:one => :two})
       lambda { @request.query_string }.should raise_error(ArgumentError)
     end
   end
-
-  describe "when converting to json" do
-    before do
-      @request = Puppet::Indirector::Request.new(:facts, :find, "foo")
-    end
-
-    it "should produce a hash with the document_type set to 'request'" do
-      @request.should set_json_document_type_to("Puppet::Indirector::Request")
-    end
-    
-    it "should set the 'key'" do
-      @request.should set_json_attribute("key").to("foo")
-    end
-
-    it "should include an attribute for its indirection name" do
-      @request.should set_json_attribute("type").to("facts")
-    end
-
-    it "should include a 'method' attribute set to its method" do
-      @request.should set_json_attribute("method").to("find")
-    end
-
-    it "should add all attributes under the 'attributes' attribute" do
-      @request.ip = "127.0.0.1"
-      @request.should set_json_attribute("attributes", "ip").to("127.0.0.1")
-    end
-
-    it "should add all options under the 'attributes' attribute" do
-      @request.options["opt"] = "value"
-      PSON.parse(@request.to_pson)["data"]['attributes']['opt'].should == "value"
-    end
-
-    it "should include the instance if provided" do
-      facts = Puppet::Node::Facts.new("foo")
-      @request.instance = facts
-      PSON.parse(@request.to_pson)["data"]['instance'].should be_instance_of(Puppet::Node::Facts)
-    end
-  end
-
-  describe "when converting from json" do
-    before do
-      @request = Puppet::Indirector::Request.new(:facts, :find, "foo")
-      @klass = Puppet::Indirector::Request
-      @format = Puppet::Network::FormatHandler.format('pson')
-    end
-
-    def from_json(json)
-      @format.intern(Puppet::Indirector::Request, json)
-    end
-
-    it "should set the 'key'" do
-      from_json(@request.to_pson).key.should == "foo"
-    end
-
-    it "should fail if no key is provided" do
-      json = PSON.parse(@request.to_pson)
-      json['data'].delete("key")
-      lambda { from_json(json.to_pson) }.should raise_error(ArgumentError)
-    end
-
-    it "should set its indirector name" do
-      from_json(@request.to_pson).indirection_name.should == :facts
-    end
-
-    it "should fail if no type is provided" do
-      json = PSON.parse(@request.to_pson)
-      json['data'].delete("type")
-      lambda { from_json(json.to_pson) }.should raise_error(ArgumentError)
-    end
-
-    it "should set its method" do
-      from_json(@request.to_pson).method.should == "find"
-    end
-
-    it "should fail if no method is provided" do
-      json = PSON.parse(@request.to_pson)
-      json['data'].delete("method")
-      lambda { from_json(json.to_pson) }.should raise_error(ArgumentError)
-    end
-
-    it "should initialize with all attributes and options" do
-      @request.ip = "127.0.0.1"
-      @request.options["opt"] = "value"
-      result = from_json(@request.to_pson)
-      result.options[:opt].should == "value"
-      result.ip.should == "127.0.0.1"
-    end
-
-    it "should set its instance as an instance if one is provided" do
-      facts = Puppet::Node::Facts.new("foo")
-      @request.instance = facts
-      result = from_json(@request.to_pson)
-      result.instance.should be_instance_of(Puppet::Node::Facts)
-    end
-  end
 end