resto 0.0.3 → 0.0.4

data/lib/resto/validate.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Resto
+  module Validate
+
+    autoload :Inclusion,  'resto/validate/inclusion'
+    autoload :Length,     'resto/validate/length'
+    autoload :Presence,   'resto/validate/presence'
+
+    def initialize
+      @if     = lambda { |resource| true  }
+      @unless = lambda { |resource| false }
+    end
+
+    def validate?(resource)
+      (@if.call(resource) && !@unless.call(resource))
+    end
+
+    def message(error_message)
+      tap { @message = error_message }
+    end
+
+    def if(&block)
+      tap { @if = block }
+    end
+
+    def unless(&block)
+      tap { @unless = block }
+    end
+
+    # .on - Specifies when this validation is active (default is :save, other
+    # options :create, :update).
+    # def on(args)
+    #  tap { }
+    # end
+  end
+end

data/lib/resto/validate/inclusion.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Resto
+  module Validate
+    class Inclusion
+      include Validate
+
+      def initialize
+        @allow_nil = false
+        @allow_blank = false
+      end
+
+      def in(range)
+        tap { @range = range }
+      end
+
+      def allow_nil
+        tap { @allow_nil = true }
+      end
+
+      def allow_blank
+        tap { @allow_blank = true }
+      end
+    end
+  end
+end
+#
+# .in - An enumerable object of available items. %w( m f ), 0..99,  %w( jpg gif png )
+# .message - Specifies a custom error message (default is: “is not included in the list”).
+# .allow_nil - If set to true, skips this validation if the attribute is nil (default is false).
+# .allow_blank - If set to true, skips this validation if the attribute is blank (default is false).
+# .if - Specifies a method, proc or string to call to determine if the validation should occur
+#      (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method,
+#      proc or string should return or evaluate to a true or false value.
+# .unless - Specifies a method, proc or string to call to determine if the validation should not occur
+#           (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).
+#           The method, proc or string should return or evaluate to a true or false value.
+
+

data/lib/resto/validate/length.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Resto
+  module Validate
+    class Length
+      include Validate
+
+      def is(number)
+        tap { @number = number }
+      end
+
+    end
+  end
+end
+# .is - The exact size of the attribute.
+# .within - A range specifying the minimum and maximum size of the attribute.
+# .allow_nil - Attribute may be nil; skip validation.
+# .allow_blank - Attribute may be blank; skip validation.
+# .if - Specifies a method, proc or string to call to determine if the
+# validation should occur (e.g. :if => :allow_validation, or :if =>
+# Proc.new { |user| user.signup_step > 2 }). The method, proc or string should
+# return or evaluate to a true or false value.
+# .unless - oposite of .if
+#
+# messages
+# :too_long - The error message if the attribute goes over the maximum
+# (default is: “is too long (maximum is %count characters)”).
+# :too_short - The error message if the attribute goes under the minimum
+# (default is: “is too short (min is %count characters)”).
+# :wrong_length - The error message if using the :is method and the attribute
+# is the wrong size (default is: “is the wrong length
+# (should be %count characters)”).
+# :message - The error message to use for a :minimum, :maximum, or
+# :is violation. An alias of the appropriate too_long/too_short/wrong_length
+# message.
+

data/lib/resto/validate/presence.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Resto
+  module Validate
+    class Presence
+      include Validate
+
+      def attribute_value(resource, attribute_method)
+
+        error_key = (attribute_method.to_s + "_presence").to_sym
+        value_before_cast = resource.send("#{attribute_method}_without_cast")
+
+        error =
+          if (validate?(resource) && value_before_cast.to_s.strip.empty?)
+            ":#{attribute_method} #{@message || "can’t be blank"}"
+          else
+            nil
+          end
+
+        resource.add_error(error_key, error)
+      end
+    end
+  end
+end

data/lib/resto/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Resto
+  VERSION = "0.0.4"
+end

data/resto.gemspec

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+
+require File.expand_path("../lib/resto/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "resto"
+  s.version     = Resto::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Anders Törnqvist"]
+  s.email       = ["anders@elabs.se"]
+  s.homepage    = "http://rubygems.org/gems/resto"
+  s.summary     = "Restful Web Service"
+  s.description = "Restful Web Service"
+
+  s.required_ruby_version = ::Gem::Requirement.new(">= 1.8.7")
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "resto"
+
+  s.add_runtime_dependency "yajl-ruby", "0.8.2"
+  s.add_runtime_dependency "nokogiri", ">=1.4.4"
+  # s.add_dependency "activesupport", "3.0.0" ???
+  s.add_development_dependency "bundler", ">= 1.0.11"
+  s.add_development_dependency "rspec",   ">= 2.5.0"
+  s.add_development_dependency "fuubar",   ">= 0.0.4"
+  s.add_development_dependency "webmock", ">= 1.6.2"
+  s.add_development_dependency "code-cleaner", ">= 0.8.2"
+  s.add_development_dependency "reek"
+  s.add_development_dependency "metrical"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "ephemeral_response"
+
+  # CLI testing
+  # http://github.com/radar/guides/blob/master/gem-development.md
+  # s.add_dependency "thor"
+  # s.add_development_dependency "cucumber"
+  # s.add_development_dependency "aruba"
+
+  s.files = Dir.glob("{lib,spec}/**/*") + %w(resto.gemspec)
+  # s.files        = `git ls-files`.split("\n")
+  #s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/spec/resto/extra/copy_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'resto/extra/copy'
+describe Resto::Extra::Copy do
+  describe ".request_base" do
+    before do
+      @request_base = Resto::Request::Base.new.port(40)
+        .url('http://www.aftonbladet.se:92/customers')
+        .query('q=adam')
+        .path('contacts')
+
+      @new_request_base = Resto::Extra::Copy.request_base(@request_base)
+        .url('http://new.se:99/other')
+        .query('q=not-same')
+        .path('other-contacts/')
+        .headers({ "accept"=> "other", "user-agent"=> "Ruby" })
+        .append_path(2)
+    end
+
+    it { @new_request_base.object_id.should_not == @request_base.object_id }
+    it { @request_base.read_port.should == 40 }
+    it { @request_base.composed_path.should  == '/contacts?q=adam' }
+
+    it do
+      @request_base.composed_headers.should  == { "accept"=> "*/*",
+                                                  "user-agent"=> "Ruby" }
+    end
+
+    it do
+      @request_base.composed_headers.object_id.should_not ==
+        @new_request_base.composed_headers.object_id
+    end
+
+    it { @new_request_base.read_port.should == 40 }
+
+    it do
+      @new_request_base.composed_headers.should == {  "accept"=> "other",
+                                                      "user-agent"=> "Ruby" }
+    end
+
+    it do
+      @new_request_base.composed_path.should == "/other-contacts/2?q=not-same"
+    end
+  end
+
+  describe ".response_base" do
+    before do
+      @response_base = Resto::Response::Base.new.format(:json)
+      @new_response_base = Resto::Extra::Copy.response_base(@response_base)
+        .http_response('response')
+    end
+
+    it { @response_base.instance_eval { @response }.should == nil }
+    it { @new_response_base.object_id.should_not  == @response_base.object_id }
+    it { @new_response_base.instance_eval { @response }.should == 'response' }
+  end
+end

data/spec/resto/extra/hash_args_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'resto/extra/hash_args'
+
+describe Resto::Extra::HashArgs do
+
+  class_context(%Q{
+    class BasicAuthication < Resto::Extra::HashArgs
+      key :username
+      key :password
+    end}) do
+
+    it "returns the value from the block when no value is found by key" do
+      BasicAuthication.new(nil).fetch(:username) { 'anders' }.should == 'anders'
+    end
+
+    it "returns the value found by the key"  do
+      BasicAuthication.new({'username' => 'anders', :password => 'secret'})
+        .fetch(:password) { 'other' }.should == 'secret'
+    end
+
+    it "the key is translated to its symbol" do
+      BasicAuthication.new({'username' => 'anders', :password => 'secret'})
+        .fetch(:username) { 'other' }.should == 'anders'
+    end
+  end
+
+  class_context(%Q{
+    class FormatExt < Resto::Extra::HashArgs
+      key :extension
+    end}) do
+
+    it "returns the value from the block" do
+      FormatExt.new({}).fetch(:extension) { 'block' }.should == 'block'
+    end
+
+    if RUBY_VERSION < '1.9'
+
+      it "raises IndexError when no value and no block" do
+        expect { FormatExt.new({}).fetch(:extension) }
+          .to raise_error(IndexError, 'key not found')
+      end
+
+    else
+
+      it "raises KeyError when no value and no block" do
+        lambda { FormatExt.new({}).fetch(:extension) }
+          .should raise_error(KeyError, 'key not found: :extension')
+      end
+
+    end
+
+    it "raises" do
+      expect { FormatExt.new({:username => "anders"}) }
+        .to raise_error(ArgumentError, /The key 'username'/)
+
+      expect { FormatExt.new("string") }
+        .to raise_error(ArgumentError, "'string' must be a Hash")
+
+      expect { FormatExt.new(:extension => 'value', 'extension' => 'value') }
+        .to raise_error(ArgumentError, "duplicated keys: extension, extension")
+
+      expect { FormatExt.new({:invalid_key => 'invalid' }) }
+        .to raise_error(ArgumentError, /The key 'invalid_key' is not valid/)
+
+      expect { FormatExt.new({:extension => 'value' }).fetch(:invalid_key) }
+        .to raise_error(ArgumentError, /The key 'invalid_key' is not valid/)
+    end
+  end
+end

data/spec/resto/format/default_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'resto/format'
+
+describe "Resto::Format.get" do
+  subject { Resto::Format.get }
+
+  its(:extension)    { should == nil   }
+  its(:accept)       { should == '*/*' }
+  its(:content_type) { should == nil   }
+  describe ".encode(text)" do
+    it("returns text") do
+      subject.encode('very important').should == 'very important'
+    end
+  end
+
+  describe ".decode(text)" do
+    it("returns text") do
+      subject.encode('somehting important').should == 'somehting important'
+    end
+  end
+
+end

data/spec/resto/format/json_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'resto/format'
+require 'yajl'
+
+describe "Resto::Format.get(:json)" do
+  subject { Resto::Format.get(:json) }
+
+  its(:extension)      { should == 'json' }
+  its(:accept)         { should == 'application/json, */*' }
+  its(:content_type)   { should == 'application/json' }
+
+  describe ".encode(hash)" do
+    before { @result = subject.encode({ :bar => "some string",
+                                        :foo => 12425125}) }
+
+    it { @result.should =~ /bar\":\"some string/ }
+    it { @result.should =~ /foo\":12425125/      }
+  end
+
+  describe '.decode(json)' do
+    json = Yajl::Encoder.encode( { :foo => 12425125, :bar => "some string" })
+    expected = { 'foo' => 12425125, 'bar' => "some string" }
+
+    it { subject.decode(json).should == expected }
+  end
+
+end

data/spec/resto/format/plain_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'resto/format'
+
+describe "Resto::Format.get(:plain)" do
+  subject { Resto::Format.get(:plain) }
+
+  its(:extension)    { should == nil }
+  its(:accept)       { should == 'text/plain, */*' }
+  its(:content_type) { should == 'text/plain' }
+
+  context ".encode(text)" do
+    it("returns text") { subject.encode('important').should == 'important' }
+  end
+
+  context ".decode(text)" do
+    it("returns text") { subject.encode('important').should == 'important' }
+  end
+
+end

data/spec/resto/format/xml_spec.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'resto/format'
+
+describe "Resto::Format.get(:xml)" do
+  subject { Resto::Format.get(:xml) }
+
+  its(:extension)         { should == 'xml' }
+  its(:accept)            { should == 'application/xml, */*' }
+  its(:content_type)      { should == 'application/xml;charset=utf-8' }
+
+  let(:hash) do
+    {:zone =>
+      { 'default-ttl' => 600,
+        'domain' => "example.com",
+        'ns1' => nil,
+        'ns-type' => "pri_sec",
+        'nx-ttl' => 900,
+        'slave-nameservers' => nil
+      }
+    }
+  end
+
+  describe ".encode(hash)" do
+    before { @result = subject.encode(hash) }
+
+    it { @result.should =~ /<\?xml version=\"1.0\"\?>/ }
+    it { @result.should =~ /<zone>.+<\/zone>\Z/m }
+    it { @result.should =~ /<default-ttl>600<\/default-ttl>/ }
+    it { @result.should =~ /<ns1\/>/ }
+    it { @result.should =~ /<slave-nameservers\/>/ }
+  end
+
+  let(:xml) do
+    '<?xml version="1.0"?><zone>
+    <default-ttl>600</default-ttl>
+    <domain>example.com</domain>
+    <ns1/>
+    <ns-type>pri_sec</ns-type>
+    <nx-ttl>900</nx-ttl>
+    <slave-nameservers/>
+    </zone>'
+  end
+
+  let(:xml_collection) do
+    '<?xml version="1.0"?>
+    <zones>
+      <zone>
+        <default-ttl>600</default-ttl>
+        <domain>example.com</domain>
+        <ns1/>
+        <ns-type>pri_sec</ns-type>
+        <nx-ttl>900</nx-ttl>
+        <slave-nameservers/>
+      </zone>
+      <zone>
+        <default-ttl>700</default-ttl>
+        <domain>example.com</domain>
+        <ns1/>
+        <ns-type>pri_sec</ns-type>
+        <nx-ttl>800</nx-ttl>
+        <slave-nameservers/>
+      </zone>
+      </zones>'
+  end
+
+  let(:attributes) do
+    { 'default-ttl' => "600",
+      'domain' => "example.com",
+      'ns1' => "",
+      'ns-type' => "pri_sec",
+      'nx-ttl' => "900",
+      'slave-nameservers' => ""
+    }
+  end
+
+  let(:second_attributes) do
+    { 'default-ttl' => "700",
+      'domain' => "example.com",
+      'ns1' => "",
+      'ns-type' => "pri_sec",
+      'nx-ttl' => "800",
+      'slave-nameservers' => ""
+    }
+  end
+
+  describe '.decode(xml, xpath)' do
+    context 'when one item' do
+      it { subject.decode(xml, :xpath => '//zone').should == attributes }
+    end
+
+    context 'when 0 items' do
+      it { subject.decode(xml, :xpath => '//xx0').should == {} }
+    end
+
+    context 'when a collection of two items' do
+      it do
+        subject.decode(xml_collection, :xpath => '//zone').should ==
+          [attributes, second_attributes]
+      end
+    end
+  end
+
+end