dupe 0.3.7 → 0.4.0

data/lib/dupe/log.rb

@@ -0,0 +1,38 @@
+class Dupe
+  class Network #:nodoc:
+    class Log #:nodoc:
+      include RestValidation     #:nodoc:
+      attr_reader :requests    #:nodoc:
+      
+      class Request     #:nodoc:
+        attr_reader :verb, :path, :response_body
+        
+        def initialize(verb, path, response_body)
+          @verb, @path, @response_body = verb, path, response_body
+        end
+        
+        def pretty_print
+          "Request: #{@verb.to_s.upcase} #{@path}\n" +
+          "Response:\n" + @response_body.indent
+        end
+      end
+      
+      def initialize     #:nodoc:
+        @requests = []
+      end
+      
+      def add_request(verb, path, response_body='')     #:nodoc:
+        validate_request_type verb
+        @requests << Request.new(verb, path, response_body)
+      end
+      
+      def pretty_print
+        "Logged Requests:\n" + requests.map {|r| r.pretty_print.indent }.join("\n\n") + "\n\n"
+      end
+      
+      def reset #:nodoc:
+        @requests = []
+      end
+    end
+  end
+end

data/lib/dupe/mock.rb

@@ -0,0 +1,50 @@
+class Dupe
+  class Network #:nodoc:
+    class Mock #:nodoc:
+      include Dupe::Network::RestValidation
+      
+      attr_reader :verb
+      attr_reader :url_pattern
+      attr_reader :response
+    
+      def initialize(verb, url_pattern, response_proc=nil)
+        validate_request_type verb
+        
+        raise(
+          ArgumentError,
+          "The URL pattern parameter must be a type of regular expression."
+        ) unless url_pattern.kind_of?(Regexp)
+            
+        @response = response_proc || proc {}
+        @verb = verb
+        @url_pattern = url_pattern
+      end
+    
+      def match?(url)
+        url_pattern =~ url ? true : false
+      end
+    
+      def mocked_response(url)
+        raise(
+          StandardError, 
+          "Tried to mock a response to a non-matched url! This should never occur."
+        ) unless match?(url)
+      
+        grouped_results = url_pattern.match(url)[1..-1]
+        resp = @response.call *grouped_results
+      
+        case resp
+          when Dupe::Database::Record
+            resp = resp.to_xml(:root => resp.__model__.name.to_s)
+          when Array
+            resp = resp.to_xml(:root => resp.first.__model__.name.to_s.pluralize)
+        end
+        
+        Dupe.network.log.add_request @verb, url, resp
+        
+        resp
+      end
+    
+    end
+  end
+end

data/lib/dupe/model.rb

@@ -0,0 +1,55 @@
+class Dupe
+  class Model #:nodoc:
+    attr_reader :schema
+    attr_reader :name
+    attr_reader :id_sequence
+    
+    def initialize(name)
+      @schema = Dupe::Model::Schema.new
+      @name   = name.to_sym
+      @id_sequence = Sequence.new
+    end
+    
+    def define(definition_proc)
+      definition_proc.call @schema
+    end
+    
+    def create(attributes={})
+      Database::Record.new.tap do |record|
+        record.__model__ = self
+        record.id = @id_sequence.next
+        record.merge! default_record
+        record.merge! transform(attributes)
+        @schema.after_create_callbacks.each do |callback|
+          callback.call record
+        end
+      end
+    end
+    
+    private
+    def default_record
+      Database::Record.new.tap do |record|
+        # setup all the required attributes
+        @schema.attribute_templates.each do |attribute_template_name, attribute_template|
+          required_attribute_name, required_attribute_value = 
+            attribute_template.generate
+          record[required_attribute_name] = required_attribute_value
+        end
+      end
+    end
+    
+    def transform(attributes)
+      Database::Record.new.tap do |record|
+        # override the required attributes or create new attributes
+        attributes.each do |attribute_name, attribute_value|
+          if @schema.attribute_templates[attribute_name]
+            k, v = @schema.attribute_templates[attribute_name].generate attribute_value
+            record[attribute_name] = v
+          else
+            record[attribute_name] = attribute_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dupe/network.rb

@@ -0,0 +1,38 @@
+class Dupe
+  class Network    #:nodoc:
+    include RestValidation #:nodoc:
+    
+    class RequestNotFoundError < StandardError; end #:nodoc:
+    
+    attr_reader :mocks, :log
+    
+    def initialize
+      @mocks = {}
+      @log = Dupe::Network::Log.new
+      VERBS.each { |verb| @mocks[verb] = [] }
+    end
+        
+    def request(verb, url)
+      validate_request_type verb
+      match(verb, url).mocked_response(url)
+    end
+    
+    def define_service_mock(verb, url_pattern, response_proc=nil)
+      Mock.new(verb, url_pattern, response_proc).tap do |mock|
+        @mocks[verb] << mock
+      end
+    end
+    
+    private
+    def match(verb, url)
+      @mocks[verb].each do |mock|
+        return mock if mock.match?(url)
+      end
+      raise(
+        RequestNotFoundError,
+        "No mocked service response found for '#{url}'"
+      )
+    end
+    
+  end
+end

data/lib/dupe/record.rb

@@ -1,63 +1,42 @@
 class Dupe
-  class Record    
-    attr_accessor :internal_attributes_hash
-    
-    def initialize(hash={})
-      @internal_attributes_hash = 
-        hash.merge(hash) do |k,v| 
-          process_value(v)
+  class Database #:nodoc:
+    class Record < Hash #:nodoc:
+      attr_accessor :__model__
+      
+      def id
+        self[:id]
+      end
+      
+      def id=(value)
+        self[:id] = value
+      end
+      
+      def method_missing(method_name, *args, &block)
+        if attempting_to_assign(method_name)
+          method_name = method_name.to_s[0..-2].to_sym
+          self[method_name] = args.first
+        else
+          self[method_name.to_sym]
         end
-    end
+      end
 
-    # allows you to access a record like: 
-    #   irb> book = Dupe::Record.new :title => 'The Carpet Makers', :author => {:name => 'Andreas Eschbach'}
-    #   irb> book.title
-    #     ==> 'The Carpet Makers'
-    #   irb> book.author.name
-    #     ==> 'Andreas Eschbach'
-    #   irb> book.genre = 'Science Fiction'
-    #   irb> book.genre
-    #     ==> 'Science Fiction'
-    def method_missing(method_name, *args, &block)
-      if method_name.to_s[-1..-1] == '='
-        @internal_attributes_hash[method_name.to_s[0..-2].to_sym] = 
-          process_value(args[0])
-      else
-        @internal_attributes_hash[method_name.to_sym]
+      def record_inspect
+        class_name = __model__ ? "Duped::#{__model__.name.to_s.titleize}" : self.class.to_s
+        "<##{class_name}".tap do |inspection|
+          keys.each do |key|
+            inspection << " #{key}=#{self[key].inspect}"
+          end
+          inspection << ">"
+        end
       end
-    end
-    
-    # allows you to access a record like: 
-    #   irb> book = Dupe::Record.new :title => 'The Carpet Makers', :author => {:name => 'Andreas Eschbach'}
-    #   irb> book[:title]
-    #     ==> 'The Carpet Makers'
-    #   irb> book[:author][:name]
-    #     ==> 'Andreas Eschbach'
-    #   irb> book.genre = 'Science Fiction'
-    #   irb> book.genre
-    #     ==> 'Science Fiction'
-    def [](key)
-      @internal_attributes_hash[key.to_sym]
-    end
-    
-    # allows you to set a record like: 
-    #   irb> book = Dupe::Record.new :title => 'The Carpet Makers', :author => {:name => 'Andreas Eschbach'}
-    #   irb> book[:genre] = 'Science Fiction'
-    #   irb> book[:genre]
-    #     ==> 'Science Fiction'
-    def []=(key, value)
-      @internal_attributes_hash[key.to_sym] = process_value(value)
-    end
-        
-    private
-    def process_value(v)
-      if v.is_a?(Hash) 
-        Record.new(v)
-      elsif v.is_a?(Array)
-        v.map {|r| process_value(r)}
-      else
-        v
+      
+      alias_method :hash_inspect, :inspect
+      alias_method :inspect, :record_inspect
+      
+      private
+      def attempting_to_assign(method_name)
+        method_name.to_s[-1..-1] == '=' 
       end
     end
   end
-end
+end

data/lib/dupe/rest_validation.rb

@@ -0,0 +1,16 @@
+class Dupe
+  class Network #:nodoc:
+    #:nodoc:
+    class UnknownRestVerbError < StandardError; end #:nodoc:
+    VERBS = [:get, :post, :put, :delete] #:nodoc:
+    
+    module RestValidation  #:nodoc:
+      def validate_request_type(verb)
+        raise(
+          Dupe::Network::UnknownRestVerbError,
+          "Unknown REST verb ':#{verb}'. Valid REST verbs are :get, :post, :put, and :delete."
+        ) unless Dupe::Network::VERBS.include?(verb)
+      end
+    end
+  end
+end

data/lib/dupe/schema.rb

@@ -0,0 +1,36 @@
+class Dupe
+  class Model #:nodoc:
+    class Schema #:nodoc:
+      attr_reader :attribute_templates
+      attr_reader :after_create_callbacks
+      
+      def initialize
+        @attribute_templates = {}
+        @after_create_callbacks = []
+      end
+      
+      def method_missing(method_name, *args, &block)
+        attribute_name = method_name.to_s[-1..-1] == '=' ? method_name.to_s[0..-2].to_sym : method_name
+        if block && block.arity < 1
+          default_value = block
+          transformer = nil
+        else
+          default_value = args[0]
+          transformer = block
+        end
+        
+        @attribute_templates[method_name.to_sym] = 
+          AttributeTemplate.new method_name.to_sym, :default => default_value, :transformer => transformer
+      end
+      
+      def after_create(&block)
+        raise(
+          ArgumentError, 
+          "You must pass a block that accepts a single parameter to 'after_create'"
+        ) if !block || block.arity != 1
+        
+        @after_create_callbacks << block
+      end
+    end
+  end
+end

data/lib/dupe/sequence.rb

@@ -1,11 +1,12 @@
-class Dupe
-  class Sequence  #:nodoc:
-    def initialize(start=0)
-      @sequence_value = start
-    end
-
-    def next
-      @sequence_value += 1
-    end
+class Sequence #:nodoc:
+  attr_reader :current_value 
+  
+  def initialize(starting_at=1)
+    @current_value = starting_at
   end
-end
+  
+  def next
+    @current_value += 1
+    @current_value - 1
+  end
+end

data/lib/dupe/singular_plural_detection.rb

@@ -0,0 +1,9 @@
+module SingularPluralDetection #:nodoc:
+  def singular?
+    self.to_s.singularize == self.to_s
+  end
+  
+  def plural?
+    self.to_s.pluralize == self.to_s
+  end
+end

data/lib/dupe/string.rb

@@ -1,9 +1,7 @@
-class String
-  def plural?
-    self.to_s == pluralize
+class String #:nodoc:
+  include SingularPluralDetection
+  
+  def indent(spaces=2)
+    split("\n").map {|l| (" " * spaces) + l }.join("\n")
   end
-
-  def singular?
-    self.to_s == singularize
-  end
-end
+end

data/lib/dupe/symbol.rb

@@ -0,0 +1,3 @@
+class Symbol #:nodoc:
+  include SingularPluralDetection
+end

data/lib/dupe.rb

@@ -1,18 +1,19 @@
 require 'active_resource'
 require 'active_resource/http_mock'
+require 'dupe/singular_plural_detection'
+require 'dupe/symbol'
 require 'dupe/string'
+require 'dupe/rest_validation'
+require 'dupe/mock'
+require 'dupe/log'
+require 'dupe/network'
 require 'dupe/dupe'
+require 'dupe/database'
 require 'dupe/sequence'
-require 'dupe/mock_service_response'
-require 'dupe/configuration'
-require 'dupe/attribute'
-require 'dupe/active_resource'
-require 'dupe/cucumber_hooks'
 require 'dupe/record'
-
-path = defined?(RAILS_ROOT) ? RAILS_ROOT + '/features/dupe_definitions' : '../features/dupe_definitions'
-if File.directory? path
-  Dir[File.join(path, '*.rb')].each do |file|
-    require file
-  end
-end
+require 'dupe/attribute_template'
+require 'dupe/schema'
+require 'dupe/model'
+require 'dupe/custom_mocks'
+require 'dupe/active_resource_extensions'
+require 'dupe/cucumber_hooks'

data/rails_generators/dupe/templates/custom_mocks.rb

@@ -1,34 +1,4 @@
-module CustomMocks
-  # Maps a service request url to a Dupe find. By default, Dupe will only
-  # mock simple requests like SomeResource.find(some_id) or SomeResource.find(:all)
-  #
-  # For example, suppose you have a Book < ActiveResource::Base class, and
-  # somewhere your code does:
-  #
-  #   Book.find :all, :params => {:limit => 10, :offset => 20}
-  #
-  # That in turn will send off a request to a url like:
-  #
-  #   /books.xml?limit=10&offset=20
-  #
-  # In this file, you could add a "when" statement like:
-  #
-  #   when %r{/books.xml\?limit=(\d+)&offset=(\d+)$}
-  #     start = $2.to_i
-  #     finish = start + $1.to_i - 1
-  #     Dupe.find(:books)[start..finish]
-  def custom_service(url)
-    case url
-
-      # remove this and replace it with a real custom mock
-      when %r{/bogus_url}
-        ''
-
-      else
-        raise StandardError.new(
-          "There is no custom service mapping for \"#{url}\"." +
-          "Now go to features/support/custom_mocks.rb and add it."
-        )
-    end
-  end
-end
+# Example:
+# Get %r{/books/([\d\w-]+)\.xml} do |label|
+#   Dupe.find(:book) {|b| b.label == label}
+# end

data/rails_generators/dupe/templates/dupe_setup.rb

@@ -1,23 +1,3 @@
-Dupe.configure do |global_config|
-  # set this to false if you don't want to see the mocked
-  # xml output after each scenario
-  global_config.debug true
-end
-
-# You can also place your resource definitions in this file. 
-=begin
-  # Example resource definition
-  Dupe.define :books do |book|
-    book.name 'default name'
-
-    # supporting Dupe.create :book, :genre => 'Sci-fi'
-    book.genre do |genre_name|
-      Dupe.find(:genre) {|g| g.name == genre_name}
-    end
-
-    # supporting Dupe.create :book, :authors => 'Arthur C. Clarke, Gentry Lee'
-    book.authors do |author_names|
-      Dupe.find(:authors) {|a| author_names.split(/,\ */).include?(a.name)}
-    end
-  end
-=end
+# set this to false if you don't care to see the requests mocked 
+# for each cucumber scenario.
+Dupe.debug = true

data/spec/lib_specs/active_resource_extensions_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ActiveResource::Connection do 
+  before do
+    Dupe.reset
+  end
+  
+  describe "#get" do
+    before do
+      @book = Dupe.create :book, :title => 'Rooby', :label => 'rooby'
+      class Book < ActiveResource::Base
+        self.site = ''
+      end
+    end
+    
+    it "should pass a request off to the Dupe network if the original request failed" do            
+      Dupe.network.should_receive(:request).with(:get, '/books.xml').once.and_return(Dupe.find(:books).to_xml(:root => 'books'))
+      books = Book.find(:all)
+    end
+    
+    it "should parse the xml and turn the result into active resource objects" do
+      books = Book.find(:all)
+      books.length.should == 1
+      books.first.id.should == 1
+      books.first.title.should == 'Rooby'
+      books.first.label.should == 'rooby'
+    end
+  end
+end