mirage 3.0.0.alpha.3 → 3.0.0.alpha.4

data/VERSION

@@ -1 +1 @@
-3.0.0.alpha.3
+3.0.0.alpha.4

data/lib/mirage/client.rb

@@ -1,5 +1,5 @@
 $LOAD_PATH.unshift "#{File.dirname(__FILE__)}"
-require 'client/template_configuration'
+require 'client/template'
 require 'client/error'
 require 'client/cli_bridge'
 require 'client/runner'

data/lib/mirage/client/helpers/method_builder.rb

@@ -0,0 +1,19 @@
+module Mirage
+  module Helpers
+    module MethodBuilder
+      def builder_methods *method_names
+
+        method_names.each do |method_name|
+          method_name = method_name.to_sym
+          define_method method_name do |arg=nil|
+            return instance_variable_get("@#{method_name}".to_sym) unless arg
+            instance_variable_set("@#{method_name}".to_sym, arg)
+            self
+          end
+        end
+
+      end
+      alias builder_method builder_methods
+    end
+  end
+end

data/lib/mirage/client/template.rb

@@ -3,10 +3,15 @@ require 'json'
 require 'httparty'
 require 'hashie/mash'
 
+require 'client/template/configuration'
+require 'client/template/model'
+
 module Mirage
 
   class Template
+
     include HTTParty
+    include Model::InstanceMethods
 
     class << self
       alias_method :backedup_get, :get
@@ -19,93 +24,22 @@ module Mirage
 
         template = new(response_hashie.endpoint, response_config.body)
 
-        template.id = response_hashie.id
-        template.default = response_config['default']
-        template.delay = response_config.delay
-        template.content_type = response_config.content_type
-        template.status = response_config.status
-        template.headers = response_config.headers
+        template.id response_hashie.id
+        template.default response_config['default']
+        template.delay response_config.delay
+        template.content_type response_config.content_type
+        template.status response_config.status
+        template.headers response_config.headers
 
-        template.required_parameters = request_config.parameters
-        template.required_body_content = request_config.body_content
-        template.http_method = request_config.http_method
-        template.url = url
-        template.requests_url = response_hashie.requests_url
-        template.required_headers = request_config.headers
+        template.required_parameters request_config.parameters
+        template.required_body_content request_config.body_content
+        template.http_method request_config.http_method
+        template.url url
+        template.requests_url response_hashie.requests_url
+        template.required_headers request_config.headers
 
         template
       end
     end
-
-    format :json
-
-    attr_accessor :content_type, :http_method, :default, :status, :delay, :required_parameters, :required_body_content, :required_headers, :endpoint, :id, :url, :requests_url, :headers
-    attr_reader :value
-
-
-    def initialize endpoint, response, default_config=TemplateConfiguration.new
-
-      @endpoint = endpoint
-      @content_type = default_config.content_type
-      @value = response
-      @http_method = default_config.http_method
-      @status = default_config.status
-      @delay = default_config.delay
-      @required_parameters = {}
-      @required_headers = {}
-      @required_body_content = []
-      @headers = {}
-      @default = default_config.default
-    end
-
-    def create
-      @id = self.class.put("#{@endpoint}", :body => self.to_json, :headers => {'content-type' => 'application/json'})['id']
-      self
-    end
-
-    def delete
-      self.class.delete(url)
-      Request.delete requests_url
-    end
-
-
-    def to_json
-      {
-          :response => {
-              :body => Base64.encode64(@value),
-              :status => status,
-              :default => default,
-              :content_type => content_type,
-              :headers => headers
-
-          },
-          :request => {
-              :parameters => encode_regexs(required_parameters),
-              :headers => encode_regexs(required_headers),
-              :body_content => encode_regexs(required_body_content),
-              :http_method => http_method,
-          },
-          :delay => delay
-      }.to_json
-    end
-
-
-    def encode_regexs hash_or_array
-      case hash_or_array
-        when Array
-          hash_or_array.collect { |value| encode(value) }
-        else
-          encoded = {}
-          hash_or_array.each do |key, value|
-            encoded[key] = encode(value)
-          end
-          encoded
-      end
-    end
-
-    def encode(value)
-      value.is_a?(Regexp) ? "%r{#{value.source}}" : value
-    end
-
   end
 end

data/lib/mirage/client/template/configuration.rb

@@ -0,0 +1,25 @@
+module Mirage
+  class Template
+    class Configuration
+      attr_accessor :http_method, :status, :delay, :content_type, :default
+      DEFAULT_HTTP_METHOD=:get
+      DEFAULT_STATUS=200
+      DEFAULT_DELAY=0
+      DEFAULT_CONTENT_TYPE="text/plain"
+      DEFAULT_DEFAULT=false
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @http_method = DEFAULT_HTTP_METHOD
+        @status = DEFAULT_STATUS
+        @delay = DEFAULT_DELAY
+        @content_type = DEFAULT_CONTENT_TYPE
+        @default = DEFAULT_DEFAULT
+      end
+
+    end
+  end
+end

data/lib/mirage/client/template/model.rb

@@ -0,0 +1,30 @@
+
+require 'client/helpers/method_builder'
+require 'client/template/model/class_methods'
+require 'client/template/model/instance_methods'
+
+module Mirage
+  class Template
+    module Model
+
+      class << self
+        def extended clazz
+          clazz.extend(ClassMethods)
+          clazz.send(:include, HTTParty)
+          clazz.send(:include, InstanceMethods)
+
+          clazz.class_eval do
+            def initialize
+              super self.class.endpoint, ''
+              status self.class.status if self.class.status
+            end
+          end
+
+          clazz.format :json
+          clazz
+        end
+      end
+    end
+
+  end
+end

data/lib/mirage/client/template/model/class_methods.rb

@@ -0,0 +1,11 @@
+module Mirage
+  class Template
+    module Model
+      module ClassMethods
+        extend Helpers::MethodBuilder
+        include Helpers::MethodBuilder
+        builder_method :endpoint, :status
+      end
+    end
+  end
+end

data/lib/mirage/client/template/model/instance_methods.rb

@@ -0,0 +1,88 @@
+module Mirage
+  class Template
+    module Model
+      module InstanceMethods
+        extend Helpers::MethodBuilder
+
+        def initialize endpoint, response, default_config=Template::Configuration.new
+          @endpoint = endpoint
+          @content_type = default_config.content_type
+          @value = response
+          @http_method = default_config.http_method
+          @status = default_config.status
+          @delay = default_config.delay
+          @required_parameters = {}
+          @required_headers = {}
+          @required_body_content = []
+          @headers = {}
+          @default = default_config.default
+        end
+
+        builder_method :content_type,
+                       :http_method,
+                       :default,
+                       :status,
+                       :delay,
+                       :required_parameters,
+                       :required_body_content,
+                       :required_headers,
+                       :endpoint,
+                       :id,
+                       :url,
+                       :requests_url,
+                       :headers,
+                       :value
+
+        def create
+          @id = self.class.put("#{@endpoint}", :body => self.to_json, :headers => {'content-type' => 'application/json'})['id']
+          self
+        end
+
+        def delete
+          self.class.delete(url)
+          Request.delete requests_url
+        end
+
+
+        def to_json
+          {
+              :response => {
+                  :body => Base64.encode64(value),
+                  :status => status,
+                  :default => default,
+                  :content_type => content_type,
+                  :headers => headers
+
+              },
+              :request => {
+                  :parameters => encode_regexs(required_parameters),
+                  :headers => encode_regexs(required_headers),
+                  :body_content => encode_regexs(required_body_content),
+                  :http_method => http_method,
+              },
+              :delay => delay
+          }.to_json
+        end
+
+
+        def encode_regexs hash_or_array
+          case hash_or_array
+            when Array
+              hash_or_array.collect { |value| encode(value) }
+            else
+              encoded = {}
+              hash_or_array.each do |key, value|
+                encoded[key] = encode(value)
+              end
+              encoded
+          end
+        end
+
+        def encode(value)
+          value.is_a?(Regexp) ? "%r{#{value.source}}" : value
+        end
+      end
+
+    end
+  end
+end

data/lib/mirage/client/templates.rb

@@ -4,7 +4,7 @@ module Mirage
     def initialize base_url
       @url = "#{base_url}/templates"
       @requests = Requests.new(base_url)
-      @default_config = TemplateConfiguration.new
+      @default_config = Template::Configuration.new
     end
 
     def default_config &block
@@ -18,9 +18,9 @@ module Mirage
     end
 
     def put *args
-      if args.first.is_a?(Template)
+      if args.first.class.is_a?(Template::Model)
         template = args.first
-        template.endpoint = "#{@url}/#{template.endpoint}"
+        template.endpoint "#{@url}/#{template.endpoint}"
       else
         endpoint, response = args
         template = Mirage::Template.new  "#{@url}/#{endpoint}", response, @default_config

data/mirage.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "mirage"
-  s.version = "3.0.0.alpha.3"
+  s.version = "3.0.0.alpha.4"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Leon Davis"]
-  s.date = "2013-04-21"
+  s.date = "2013-04-24"
   s.description = "Mirage aids testing of your applications by hosting mock responses so that your applications do not have to talk to real endpoints. Its accessible via HTTP and has a RESTful interface."
   s.executables = ["mirage"]
   s.extra_rdoc_files = [
@@ -58,14 +58,19 @@ Gem::Specification.new do |s|
     "lib/mirage/client/cli_bridge.rb",
     "lib/mirage/client/client.rb",
     "lib/mirage/client/error.rb",
+    "lib/mirage/client/helpers/method_builder.rb",
     "lib/mirage/client/request.rb",
     "lib/mirage/client/requests.rb",
     "lib/mirage/client/runner.rb",
     "lib/mirage/client/template.rb",
-    "lib/mirage/client/template_configuration.rb",
+    "lib/mirage/client/template/configuration.rb",
+    "lib/mirage/client/template/model.rb",
+    "lib/mirage/client/template/model/class_methods.rb",
+    "lib/mirage/client/template/model/instance_methods.rb",
     "lib/mirage/client/templates.rb",
     "mirage.gemspec",
     "mirage_server.rb",
+    "profiles.rb",
     "rakefile",
     "responses/default_responses.rb",
     "server/app.rb",
@@ -77,10 +82,14 @@ Gem::Specification.new do |s|
     "server/server.rb",
     "spec/client/cli_bridge_spec.rb",
     "spec/client/client_spec.rb",
+    "spec/client/helpers/method_builder_spec.rb",
     "spec/client/request_spec.rb",
     "spec/client/requests_spec.rb",
     "spec/client/runner_spec.rb",
-    "spec/client/template_configuration_spec.rb",
+    "spec/client/template/configuration_spec.rb",
+    "spec/client/template/model/class_methods_spec.rb",
+    "spec/client/template/model/instance_methods_spec.rb",
+    "spec/client/template/model_spec.rb",
     "spec/client/template_spec.rb",
     "spec/client/templates_spec.rb",
     "spec/resources/binary.file",

data/profiles.rb

@@ -0,0 +1 @@
+Profile.create

data/spec/client/helpers/method_builder_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Helpers::MethodBuilder do
+  it 'should give a builder_method builder method' do
+    model_class = Class.new do
+      extend Helpers::MethodBuilder
+
+      builder_method :name
+      builder_method :age
+    end
+    name, age = 'Joe', 25
+
+    person = model_class.new
+    person.name(name).age(age)
+    person.name.should == name
+    person.age.should == age
+  end
+
+  it 'should let you define more than one builder method at a time' do
+    model_class = Class.new do
+      extend Helpers::MethodBuilder
+
+      builder_methods :name, :age
+    end
+    name, age = 'Joe', 25
+
+    person = model_class.new
+    person.name(name).age(age)
+    person.name.should == name
+    person.age.should == age
+  end
+end

data/spec/client/{template_configuration_spec.rb → template/configuration_spec.rb}

@@ -3,15 +3,15 @@ require 'mirage/client'
 
 
 
-describe TemplateConfiguration do
+describe Template::Configuration do
 
   it 'should have defaults' do
-    configuration = TemplateConfiguration.new
+    configuration = Template::Configuration.new
     assert_defaults configuration
   end
 
   it 'should be reset' do
-    configuration = TemplateConfiguration.new
+    configuration = Template::Configuration.new
     configuration.http_method = :post
     configuration.status = 202
     configuration.delay = 3

data/spec/client/template/model/class_methods_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Template::Model::ClassMethods do
+  context 'class methods' do
+
+    it 'should provide a method for setting the endpoint for the class' do
+      endpoint = 'endpoint'
+      model_class = Class.new do
+        extend Template::Model::ClassMethods
+
+        endpoint endpoint
+      end
+
+      model_class.endpoint.should == endpoint
+    end
+
+  end
+
+end

data/spec/client/template/model/instance_methods_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe Template::Model::InstanceMethods do
+
+
+  let!(:model) do
+    Class.new do
+      include Template::Model::InstanceMethods
+    end
+  end
+
+  let!(:instance) do
+    model.new '', ''
+  end
+
+  it 'should provide methods for customising the model' do
+    instance.methods.should include(:content_type,
+                                 :http_method,
+                                 :default,
+                                 :status,
+                                 :delay,
+                                 :required_parameters,
+                                 :required_body_content,
+                                 :required_headers,
+                                 :endpoint,
+                                 :id,
+                                 :url,
+                                 :requests_url,
+                                 :headers,
+                                 :value)
+  end
+
+  context 'initialize' do
+    it 'requires an endpoint and value to be provided' do
+      endpoint, value = 'endpoint', 'value'
+      instance = model.new endpoint, value
+      instance.endpoint.should == endpoint
+      instance.value.should == value
+    end
+
+    it 'can use configuration for all http related config' do
+      config = Mirage::Template::Configuration.new
+      config.content_type='content_type'
+      config.http_method='method'
+      config.status='status'
+      config.default=true
+
+      instance = model.new 'endpoint', 'value', config
+      instance.content_type.should == config.content_type
+      instance.http_method.should == config.http_method
+      instance.status.should == config.status
+      instance.default.should == config.default
+    end
+  end
+
+  context 'to_json' do
+    describe 'response body' do
+      it 'should base64 encode response values' do
+        value = "value"
+        response = model.new "endpoint", value
+        JSON.parse(response.to_json)["response"]["body"].should == Base64.encode64(value)
+      end
+    end
+
+    describe 'required request parameters' do
+
+      it 'should contain expected request parameters' do
+        required_parameters = {:key => "value"}
+        instance.required_parameters required_parameters
+        JSON.parse(instance.to_json)["request"]["parameters"].should == convert_keys_to_strings(required_parameters)
+      end
+
+      it 'should encode parameter requirements that are regexs' do
+        instance.required_parameters({:key => /regex/})
+        JSON.parse(instance.to_json)["request"]["parameters"].should == convert_keys_to_strings({:key => "%r{regex}"})
+      end
+    end
+
+    describe 'required body content' do
+      it 'should contain expected body content' do
+        required_body_content = ["body content"]
+        instance.required_body_content required_body_content
+        JSON.parse(instance.to_json)["request"]["body_content"].should == required_body_content
+      end
+
+      it 'should encode body content requirements that are regexs' do
+        instance.required_body_content [/regex/]
+        JSON.parse(instance.to_json)["request"]["body_content"].should == %w(%r{regex})
+      end
+    end
+
+    describe 'required headers' do
+      it 'should contain expected headers' do
+        required_headers = {:header => "value"}
+        instance.required_headers required_headers
+        JSON.parse(instance.to_json)["request"]["headers"].should == convert_keys_to_strings(required_headers)
+      end
+
+      it 'should encode header requirements that are regexs' do
+        instance.required_headers({:header => /regex/})
+        JSON.parse(instance.to_json)["request"]["headers"].should == convert_keys_to_strings(:header => "%r{regex}")
+      end
+    end
+
+    describe 'delay' do
+      it 'should default to 0' do
+        JSON.parse(instance.to_json)["delay"].should == 0
+      end
+
+      it 'should set the delay' do
+        delay = 5
+        instance.delay delay
+        JSON.parse(instance.to_json)["delay"].should == delay
+      end
+    end
+
+    describe 'status code' do
+      it 'should default to 200' do
+        JSON.parse(instance.to_json)["response"]["status"].should == 200
+      end
+
+      it 'should set the status' do
+        status = 404
+        instance.status status
+        JSON.parse(instance.to_json)["response"]["status"].should == status
+      end
+    end
+
+    describe 'http method' do
+      it 'should default to get' do
+        JSON.parse(instance.to_json)["request"]["http_method"].should == "get"
+      end
+
+      it 'should set the http method' do
+        method = :post
+        instance.http_method(method)
+        JSON.parse(instance.to_json)["request"]["http_method"].should == "post"
+      end
+    end
+
+    describe 'response as default' do
+      it 'should be false by default' do
+        JSON.parse(instance.to_json)["response"]["default"].should == false
+      end
+
+      it 'should set the default value' do
+        default = true
+        instance.default(default)
+        JSON.parse(instance.to_json)["response"]["default"].should == default
+      end
+    end
+
+    describe 'content type' do
+      it 'should be text/plain by default' do
+        JSON.parse(instance.to_json)["response"]["content_type"].should == "text/plain"
+      end
+
+      it 'should set the default value' do
+        content_type = "application/json"
+        instance.content_type content_type
+        JSON.parse(instance.to_json)["response"]["content_type"].should == content_type
+      end
+    end
+
+    it 'should set headers' do
+      header, value = 'header', 'value'
+      instance.headers[header] = value
+      JSON.parse(instance.to_json)["response"]["headers"].should == {header => value}
+    end
+  end
+
+end

data/spec/client/template/model_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Template::Model do
+  let!(:test_class) do
+    Class.new do
+      extend Template::Model
+    end
+  end
+  context 'class' do
+    it 'should extend ClassMethods and MethodBuilder' do
+      test_class.is_a?(Template::Model::ClassMethods).should == true
+      test_class.is_a?(Helpers::MethodBuilder).should == true
+    end
+  end
+
+  context 'instances' do
+    it 'should have instance methods included' do
+      test_class.ancestors.should include(Template::Model::InstanceMethods)
+    end
+
+
+    it 'should include httparty' do
+      test_class.ancestors.should include(HTTParty)
+    end
+
+    it 'provides a method for customising the endpoint of all instances' do
+      endpoint = 'endpoint'
+      test_class.endpoint endpoint
+      test_class.new.endpoint.should == endpoint
+    end
+
+    describe 'default status' do
+      it 'sets the status of instances if set' do
+        status = 404
+        test_class.status status
+        test_class.new.status.should == status
+      end
+
+      it 'status of instances retain the global default if status is not set at the class level' do
+        test_class.new.status.should == 200
+      end
+
+    end
+  end
+
+end

data/spec/client/template_spec.rb

@@ -99,8 +99,8 @@ describe Mirage::Template do
       request_url = "base_url/requests/#{id}"
 
       template = Template.new("", "")
-      template.url = template_url
-      template.requests_url = request_url
+      template.url template_url
+      template.requests_url request_url
 
 
       template.stub(:id).and_return(id)
@@ -112,138 +112,4 @@ describe Mirage::Template do
     end
 
   end
-
-  describe "json representation" do
-
-    describe 'response body' do
-      it 'should base64 encode response values' do
-        response = Template.new "endpoint", "value"
-        JSON.parse(response.to_json)["response"]["body"].should == Base64.encode64("value")
-      end
-    end
-
-    describe 'required request parameters' do
-
-      it 'should contain expected request parameters' do
-        response = Template.new "endpoint", "value"
-        required_parameters = {:key => "value"}
-        response.required_parameters = required_parameters
-        JSON.parse(response.to_json)["request"]["parameters"].should == convert_keys_to_strings(required_parameters)
-      end
-
-      it 'should encode parameter requirements that are regexs' do
-        response = Template.new "endpoint", "value"
-        response.required_parameters = {:key => /regex/}
-        JSON.parse(response.to_json)["request"]["parameters"].should == convert_keys_to_strings({:key => "%r{regex}"})
-      end
-    end
-
-    describe 'required body content' do
-      it 'should contain expected body content' do
-        response = Template.new "endpoint", "value"
-        required_body_content = ["body content"]
-        response.required_body_content = required_body_content
-        JSON.parse(response.to_json)["request"]["body_content"].should == required_body_content
-      end
-
-      it 'should encode body content requirements that are regexs' do
-        response = Template.new "endpoint", "value"
-        response.required_body_content = [/regex/]
-        JSON.parse(response.to_json)["request"]["body_content"].should == %w(%r{regex})
-      end
-    end
-
-    describe 'required headers' do
-      it 'should contain expected headers' do
-        response = Template.new "endpoint", "value"
-        required_headers = {:header => "value"}
-        response.required_headers = required_headers
-        JSON.parse(response.to_json)["request"]["headers"].should == convert_keys_to_strings(required_headers)
-      end
-
-      it 'should encode header requirements that are regexs' do
-        response = Template.new "endpoint", "value"
-        response.required_headers = {:header => /regex/}
-        JSON.parse(response.to_json)["request"]["headers"].should == convert_keys_to_strings(:header => "%r{regex}")
-      end
-    end
-
-    describe 'delay' do
-      it 'should default to 0' do
-        response = Template.new "endpoint", "value"
-        JSON.parse(response.to_json)["delay"].should == 0
-      end
-
-      it 'should set the delay' do
-        delay = 5
-        response = Template.new "endpoint", "value"
-        response.delay = delay
-        JSON.parse(response.to_json)["delay"].should == delay
-      end
-    end
-
-    describe 'status code' do
-      it 'should default to 200' do
-        response = Template.new "endpoint", "value"
-        JSON.parse(response.to_json)["response"]["status"].should == 200
-      end
-
-      it 'should set the status' do
-        status = 404
-        response = Template.new "endpoint", "value"
-        response.status = status
-        JSON.parse(response.to_json)["response"]["status"].should == status
-      end
-    end
-
-    describe 'http method' do
-      it 'should default to get' do
-        response = Template.new "endpoint", "value"
-        JSON.parse(response.to_json)["request"]["http_method"].should == "get"
-      end
-
-      it 'should set the http method' do
-        method = :post
-        response = Template.new "endpoint", "value"
-        response.http_method = method
-        JSON.parse(response.to_json)["request"]["http_method"].should == "post"
-      end
-    end
-
-    describe 'response as default' do
-      it 'should be false by default' do
-        response = Template.new "endpoint", "value"
-        JSON.parse(response.to_json)["response"]["default"].should == false
-      end
-
-      it 'should set the default value' do
-        default = true
-        response = Template.new "endpoint", "value"
-        response.default = default
-        JSON.parse(response.to_json)["response"]["default"].should == default
-      end
-    end
-
-    describe 'content type' do
-      it 'should be text/plain by default' do
-        response = Template.new "endpoint", "value"
-        JSON.parse(response.to_json)["response"]["content_type"].should == "text/plain"
-      end
-
-      it 'should set the default value' do
-        content_type = "application/json"
-        response = Template.new "endpoint", "value"
-        response.content_type = content_type
-        JSON.parse(response.to_json)["response"]["content_type"].should == content_type
-      end
-    end
-
-    it 'should set headers' do
-      header, value = 'header', 'value'
-      template = Template.new 'endpoint', value
-      template.headers[header] = value
-      JSON.parse(template.to_json)["response"]["headers"].should == {header => value}
-    end
-
-  end
 end

data/spec/client/templates_spec.rb

@@ -54,23 +54,29 @@ describe 'templates' do
 
 
 
-    context 'template as parameter' do
+
+    context 'model as parameter' do
+      let!(:endpoint){'endpoint'}
+      let!(:model_class) do
+        Class.new do
+          extend Template::Model
+          endpoint endpoint
+        end
+      end
       before :each do
         @base_url = "base_url"
         @templates = Templates.new(@base_url)
       end
-
-      it 'should take a preconfigured template as a parameter' do
-
-        template = Template.new 'endpoint', 'value'
+      it 'should take a model as a parameter' do
+        template = model_class.new
         template.should_receive(:create)
         @templates.put template
-        template.endpoint.should == "#{@base_url}/templates/endpoint"
+        template.endpoint.should == "#{@base_url}/templates/#{endpoint}"
       end
 
       it 'should accept a block to allow the template to be customised' do
         block_called = false
-        template = Template.new 'endpoint', 'value'
+        template = model_class.new
         template.should_receive(:create)
         @templates.put(template) do |the_same_template|
           block_called = true

data/test.rb

@@ -1,27 +1,18 @@
 require './lib/mirage/client'
 
+class ServiceNowResponse
+  extend Mirage::Template::Model
 
-mirage = Mirage.start
-
-#mirage.clear
-#mirage.put('some/path/greeting', 'hello') do |response|
-#  response.http_method = :post
-#end
-#
-#template = mirage.put('some/path/greeting', 'hello Michele') do |response|
-#  response.http_method = :post
-#  response.required_parameters['name']='Michele'
-#  response.required_body_content << 'stara'
-#  response.required_headers['Custom-Header']='special'
-#end
-#
-
-
-
-
-
-
-
+  endpoint 'service_now'
 
+  builder_methods :this,:that
 
+  def value
+    "my value : #{this}, #{that}"
+  end
+end
 
+Mirage.stop
+mirage = Mirage.start
+mirage.put ServiceNowResponse.new.this('foo').that('bar')
+mirage.put ServiceNowResponse.new.this('foo').that('bar').required_body_content(%w(hello world))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mirage
 version: !ruby/object:Gem::Version
-  version: 3.0.0.alpha.3
+  version: 3.0.0.alpha.4
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-21 00:00:00.000000000 Z
+date: 2013-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -287,14 +287,19 @@ files:
 - lib/mirage/client/cli_bridge.rb
 - lib/mirage/client/client.rb
 - lib/mirage/client/error.rb
+- lib/mirage/client/helpers/method_builder.rb
 - lib/mirage/client/request.rb
 - lib/mirage/client/requests.rb
 - lib/mirage/client/runner.rb
 - lib/mirage/client/template.rb
-- lib/mirage/client/template_configuration.rb
+- lib/mirage/client/template/configuration.rb
+- lib/mirage/client/template/model.rb
+- lib/mirage/client/template/model/class_methods.rb
+- lib/mirage/client/template/model/instance_methods.rb
 - lib/mirage/client/templates.rb
 - mirage.gemspec
 - mirage_server.rb
+- profiles.rb
 - rakefile
 - responses/default_responses.rb
 - server/app.rb
@@ -306,10 +311,14 @@ files:
 - server/server.rb
 - spec/client/cli_bridge_spec.rb
 - spec/client/client_spec.rb
+- spec/client/helpers/method_builder_spec.rb
 - spec/client/request_spec.rb
 - spec/client/requests_spec.rb
 - spec/client/runner_spec.rb
-- spec/client/template_configuration_spec.rb
+- spec/client/template/configuration_spec.rb
+- spec/client/template/model/class_methods_spec.rb
+- spec/client/template/model/instance_methods_spec.rb
+- spec/client/template/model_spec.rb
 - spec/client/template_spec.rb
 - spec/client/templates_spec.rb
 - spec/resources/binary.file
@@ -340,7 +349,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -894267295153814806
+      hash: -1427932946480660425
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/mirage/client/template_configuration.rb

@@ -1,22 +0,0 @@
-module Mirage
-  class TemplateConfiguration
-    attr_accessor :http_method, :status, :delay, :content_type, :default
-    DEFAULT_HTTP_METHOD=:get
-    DEFAULT_STATUS=200
-    DEFAULT_DELAY=0
-    DEFAULT_CONTENT_TYPE="text/plain"
-    DEFAULT_DEFAULT=false
-
-    def initialize
-      reset
-    end
-
-    def reset
-      @http_method = DEFAULT_HTTP_METHOD
-      @status = DEFAULT_STATUS
-      @delay = DEFAULT_DELAY
-      @content_type = DEFAULT_CONTENT_TYPE
-      @default = DEFAULT_DEFAULT
-    end
-  end
-end