dupe 0.3.7 → 0.4.0

data/lib/dupe/active_resource.rb

@@ -1,135 +0,0 @@
-# this allows us to control when we flush out the HttpMock requests / responses
-ActiveResource::HttpMock.instance_eval do #:nodoc:
-  def reset! #:nodoc:
-  end
-
-  def reset_from_dupe! #:nodoc:
-    requests.clear
-    responses.clear
-  end
-
-  def delete_mock(http_method, path)
-    responses.reject! {|r| r[0].path == path && r[0].method == http_method}
-  end
-end
-
-# makes it possible to override existing request/response definitions
-module ActiveResource #:nodoc:
-  class HttpMock      #:nodoc:
-    class Responder   #:nodoc:
-      for method in [ :post, :put, :get, :delete, :head ]
-        module_eval <<-EOE, __FILE__, __LINE__
-          def #{method}(path, request_headers = {}, body = nil, status = 200, response_headers = {})
-            @responses.reject! {|r| r[0].path == path && r[0].method == :#{method}}
-            @responses << [Request.new(:#{method}, path, nil, request_headers), Response.new(body || "", status, response_headers)]
-          end
-        EOE
-      end 
-    end
-  end
-end
-
-module CustomMocks
-  class NotImplementedError < StandardError
-  end
-  
-  def custom_service(url)
-    raise NotImplementedError.new("you must implement the CustomMocks::custom_service method.")
-  end
-end
-
-module ActiveResource
-  class Connection #:nodoc:
-    
-    include CustomMocks
-
-    class << self
-      attr_reader :request_log
-
-      def log_request(method, path, headers, response)
-        @request_log ||= []
-        @request_log << {
-          :method   => method,
-          :path     => path,
-          :headers  => headers,
-          :response => response
-        }
-      end
-
-      def flush_request_log
-        @request_log = []
-      end
-      
-      def print_request_log
-        @request_log ||= []
-        if @request_log.empty?
-          puts("\n  -----No request attempts logged for this scenario")  
-          return
-        end
-        puts "\n    Request attempts logged for this scenario:\n    --------------------------------------------\n\n"
-        @request_log.each do |request|
-          puts "    Request: #{request[:method].to_s.upcase} #{request[:path]}"
-          puts "    Headers: #{request[:headers].inspect}"
-          puts "    Response Body:\n#{request[:response].body.split("\n").map {|s| (" "*6) + s}.join("\n")}"
-          puts "    Response Code: #{request[:response].code}"
-          puts "    Response Headers: #{request[:response].headers}"
-          puts "    Response Message: #{request[:response].message}"
-          puts "\n\n"
-        end
-      end
-    end
-    
-    # Execute a GET request.
-    # Used to get (find) resources.
-    def get(path, headers = {})
-      begin
-        response = request(:get, path, build_request_headers(headers, :get))
-
-      # if the request threw an exception
-      rescue
-        # make sure that it's not a custom service that should be handled on the fly
-        response_body = custom_service(path)
-        response_body = response_body.to_xml(:root => path.match(/^\/([^\/\.]+)/)[1]) if response_body.is_a?(Hash) || response_body.is_a?(Array)
-        ActiveResource::HttpMock.respond_to do |mock|
-          mock.get path, {}, response_body
-        end
-        response = request(:get, path, build_request_headers(headers, :get))
-        ActiveResource::HttpMock.delete_mock(:get, path)
-      end
-      ActiveResource::Connection.log_request(:get, path, build_request_headers(headers, :get), response)
-      format.decode(response.body)
-    end
-
-    # Execute a DELETE request (see HTTP protocol documentation if unfamiliar).
-    # Used to delete resources.
-    def delete(path, headers = {})
-      response = request(:delete, path, build_request_headers(headers, :delete))
-      ActiveResource::Connection.log_request(:delete, path, build_request_headers(headers, :delete), response)
-      response
-    end
-
-    # Execute a PUT request (see HTTP protocol documentation if unfamiliar).
-    # Used to update resources.
-    def put(path, body = '', headers = {})
-      response = request(:put, path, body.to_s, build_request_headers(headers, :put))
-      ActiveResource::Connection.log_request(:put, path, build_request_headers(headers, :put), response)
-      response
-    end
-
-    # Execute a POST request.
-    # Used to create new resources.
-    def post(path, body = '', headers = {})
-      response = request(:post, path, body.to_s, build_request_headers(headers, :post))
-      ActiveResource::Connection.log_request(:post, path, build_request_headers(headers, :post), response) 
-      response
-    end
-
-    # Execute a HEAD request.
-    # Used to obtain meta-information about resources, such as whether they exist and their size (via response headers).
-    def head(path, headers = {})
-      response = request(:head, path, build_request_headers(headers))
-      ActiveResource::Connection.log_request(:head, path, build_request_headers(headers), response)
-      response
-    end
-  end
-end

data/lib/dupe/attribute.rb

@@ -1,17 +0,0 @@
-class Dupe 
-  class Attribute #:nodoc:
-    def initialize(name, value=nil, prock=nil)
-      @name, @value, @prock = name.to_sym, value, prock
-    end
-
-    def value(v=nil)
-      v = @value.dup if @value and !v
-      @prock && v ? @prock.call(v) : v 
-    end
-
-    def to_hash
-      {@name => value} 
-    end
-
-  end
-end

data/lib/dupe/configuration.rb

@@ -1,20 +0,0 @@
-class Dupe 
-  class Configuration #:nodoc:
-    attr_reader :config
-    
-    def initialize
-      @config ||= {}
-      @config[:record_identifiers] = [:id]
-    end
-
-    def method_missing(method_name, *args, &block)
-      set_config_option(method_name.to_sym, method_name.to_s.plural? ? args : args.first)
-    end
-
-
-    private
-    def set_config_option(key, value)
-      @config[key] = value
-    end
-  end
-end

data/lib/dupe/mock_service_response.rb

@@ -1,55 +0,0 @@
-class Dupe 
-  class MockServiceResponse #:nodoc:
-    attr_reader :mocks
-    attr_reader :resource_name
-    attr_reader :format
-
-    def initialize(resource_name, format=:xml)
-      @mocks = []
-      @resource_name = resource_name
-      @to_format = "to_#{format}"
-    end
-    
-    def define_mock(prock)
-      @mocks << prock
-    end
-
-    def method_missing(method_name, *args, &block)
-      @mocks << block
-    end
-
-    def run_mocks(records, identifiers)
-      ActiveResource::HttpMock.respond_to do |mock|
-        @mocks.each do |a_mock|
-          a_mock.call mock, records
-        end
-      end
-      find_all(records)
-      records.each {|r| find_one(r, identifiers)}
-    end
-    
-    private
-    def find_all(records)
-      ActiveResource::HttpMock.respond_to do |mock|
-        mock.get "#{prefix}#{@resource_name.to_s.pluralize}.xml",  {}, format_for_service_response(records)
-      end
-    end
-    
-    def find_one(record, identifiers)
-      ActiveResource::HttpMock.respond_to do |mock|
-        identifiers.each do |identifier|
-          mock.get "#{prefix}#{@resource_name.to_s.pluralize}/#{record[identifier]}.xml", {}, format_for_service_response(record)
-        end
-      end
-    end
-
-    def format_for_service_response(records)
-      root = (records.is_a? Array) ? @resource_name.to_s.pluralize : @resource_name.to_s
-      @format == :json ? records.to_json({:root => root}): records.to_xml({:root => root})
-    end
-
-    def prefix
-      @resource_name.to_s.camelize.constantize.prefix.gsub(/\/+/, '/') rescue "/" 
-    end
-  end
-end

data/spec/lib_specs/dupe_record_spec.rb

@@ -1,57 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "Dupe::Record" do
-  describe "the new method" do
-    it "should setup an empty internal hash when created with no parameters" do
-      r = Dupe::Record.new
-      r.internal_attributes_hash.should == {}
-    end
-    
-    it "should be accessible via missing methods" do
-      book = Dupe::Record.new :title => 'Bible', :author => {:name => 'Jebus'}
-      book.title.should == 'Bible'
-      book.author.name.should == 'Jebus'
-    end
-    
-    it "should be accessible via hash accessors" do
-      book = Dupe::Record.new :title => 'Bible', :author => {:name => 'Jebus'}
-      book[:title].should == 'Bible'
-      book[:author][:name].should == 'Jebus'
-    end
-    
-    it "should let you set attributes via method missing" do
-      book = Dupe::Record.new :title => 'Bible', :author => {:name => 'Jebus'}
-      book.genre = 'Superstition'
-      book.genre.should == 'Superstition'
-      book.chapters = [
-        {:title => 'Hair', :start => 1},
-        {:title => 'Carpet', :start => 15}
-      ]
-      book.chapters.first.title.should == 'Hair'
-      book.chapters.first.start.should == 1
-      book.chapters.last.title.should == 'Carpet'
-      book.chapters.last.start.should == 15
-    end
-    
-    it "should let you set attributes via has accessors" do
-      book = Dupe::Record.new :title => 'Bible', :author => {:name => 'Jebus'}
-      
-      # setting existing attributes
-      book[:title] = 'The Carpet Makers'
-      book[:author][:name] = 'Andreas Eschbach'
-      book[:title].should == 'The Carpet Makers'
-      book[:author][:name].should == 'Andreas Eschbach'
-      
-      # setting new attributes
-      book[:genre] = 'Science Fiction'
-      book[:genre].should == 'Science Fiction'
-      
-      # setting hash attributes
-      book[:chapters] = [
-        {:title => 'Hair', :start => 1},
-        {:title => 'Carpet', :start => 15}
-      ]
-      book[:chapters][0][:title].should == 'Hair'
-    end
-  end
-end