guillotine 1.1.0 → 1.2.0

data/lib/guillotine/adapters/sequel_adapter.rb

@@ -1,77 +1,75 @@
 module Guillotine
-  module Adapters
-    class SequelAdapter < Adapter
-      def initialize(db)
-        @db = db
-        @table = @db[:urls]
-      end
-      
-      # Public: Stores the shortened version of a URL.
-      # 
-      # url  - The String URL to shorten and store.
-      # code - Optional String code for the URL.
-      #
-      # Returns the unique String code for the URL.  If the URL is added
-      # multiple times, this should return the same code.
-      def add(url, code = nil)
-        if existing = code_for(url)
-          existing
-        else
-          code ||= shorten url
-          begin
-            @table << {:url => url, :code => code}
-          rescue Sequel::DatabaseError
-            if existing_url = @table.select(:url).where(:code => code).first
-              raise DuplicateCodeError.new(existing_url, url, code)
-            else
-              raise
-            end
+  class SequelAdapter < Adapter
+    def initialize(db)
+      @db = db
+      @table = @db[:urls]
+    end
+
+    # Public: Stores the shortened version of a URL.
+    #
+    # url  - The String URL to shorten and store.
+    # code - Optional String code for the URL.
+    #
+    # Returns the unique String code for the URL.  If the URL is added
+    # multiple times, this should return the same code.
+    def add(url, code = nil)
+      if existing = code_for(url)
+        existing
+      else
+        code ||= shorten url
+        begin
+          @table << {:url => url, :code => code}
+        rescue Sequel::DatabaseError
+          if existing_url = @table.select(:url).where(:code => code).first
+            raise DuplicateCodeError.new(existing_url, url, code)
+          else
+            raise
           end
-          code
         end
+        code
       end
+    end
 
-      # Public: Retrieves a URL from the code.
-      #
-      # code - The String code to lookup the URL.
-      #
-      # Returns the String URL.
-      def find(code)
-        select :url, :code => code
-      end
+    # Public: Retrieves a URL from the code.
+    #
+    # code - The String code to lookup the URL.
+    #
+    # Returns the String URL.
+    def find(code)
+      select :url, :code => code
+    end
 
-      # Public: Retrieves the code for a given URL.
-      #
-      # url - The String URL to lookup.
-      #
-      # Returns the String code, or nil if none is found.
-      def code_for(url)
-        select :code, :url => url
-      end
+    # Public: Retrieves the code for a given URL.
+    #
+    # url - The String URL to lookup.
+    #
+    # Returns the String code, or nil if none is found.
+    def code_for(url)
+      select :code, :url => url
+    end
 
-      # Public: Removes the assigned short code for a URL.
-      #
-      # url - The String URL to remove.
-      #
-      # Returns nothing.
-      def clear(url)
-        @table.where(:url => url).delete
-      end
+    # Public: Removes the assigned short code for a URL.
+    #
+    # url - The String URL to remove.
+    #
+    # Returns nothing.
+    def clear(url)
+      @table.where(:url => url).delete
+    end
 
-      def setup
-        @db.create_table :urls do
-          String :url
-          String :code
+    def setup
+      @db.create_table :urls do
+        String :url
+        String :code
 
-          unique :url
-          unique :code
-        end
+        unique :url
+        unique :code
       end
+    end
 
-      def select(field, query)
-        if row = @table.select(field).where(query).first
-          row[field]
-        end
+    def select(field, query)
+      if row = @table.select(field).where(query).first
+        row[field]
       end
     end
   end

data/lib/guillotine/host_checkers.rb

@@ -0,0 +1,87 @@
+module Guillotine
+  class HostChecker
+    def self.matching(arg)
+      case arg
+      when HostChecker then arg
+      else (all.detect { |ch| ch.match?(arg) } || self).new(arg)
+      end
+    end
+
+    def self.all
+      @all ||= []
+    end
+
+    attr_reader :error, :error_response
+
+    def initialize(arg = nil)
+      @error_response = [422, {}, @error]
+    end
+
+    def valid?(url)
+      true
+    end
+
+    def call(url)
+      @error_response unless valid?(url)
+    end
+  end
+
+  class RegexHostChecker < HostChecker
+    def self.match?(arg)
+      arg.is_a?(Regexp)
+    end
+
+    attr_reader :regex
+
+    def initialize(regex)
+      @error = "URL must match #{regex.inspect}"
+      @regex = regex
+      super
+    end
+
+    def valid?(url)
+      url.host.to_s =~ @regex
+    end
+  end
+
+  class StringHostChecker < HostChecker
+    def self.match?(arg)
+      arg.is_a?(String)
+    end
+
+    attr_reader :host
+
+    def initialize(host)
+      @error = "URL must be from #{host}"
+      @host = host
+      super
+    end
+
+    def valid?(url)
+      url.host == @host
+    end
+  end
+
+  class WildcardHostChecker < RegexHostChecker
+    def self.match?(arg)
+      arg.to_s =~ /^\*\.([\w\.]+)$/ && $1
+    end
+
+    class << self
+      alias host_from match?
+    end
+
+    attr_reader :pattern, :host
+
+    def initialize(pattern)
+      @pattern = pattern
+      @host = self.class.host_from(pattern)
+      @regex = %r{(^|\.)#{Regexp.escape @host}$}
+      super(@regex)
+      @error = "URL must be from #{@host}"
+    end
+  end
+
+  HostChecker.all << RegexHostChecker << WildcardHostChecker << StringHostChecker
+end
+

data/lib/guillotine/service.rb

@@ -1,13 +1,11 @@
 module Guillotine
-  class Service 
-    class NullChecker 
-      def call(url)
-      end
-    end
+  class Service
+    # Deprecated until v2
+    NullChecker = Guillotine::HostChecker
 
     # This is the public API to the Guillotine service.  Wire this up to Sinatra
     # or whatever.  Every public method should return a compatible Rack Response:
-    # [Integer Status, Hash headers, String body].  
+    # [Integer Status, Hash headers, String body].
     #
     # db            - A Guillotine::Adapter instance.
     # required_host - Either a String or Regex limiting which domains the
@@ -15,7 +13,7 @@ module Guillotine
     #
     def initialize(db, required_host = nil)
       @db = db
-      build_host_check(required_host)
+      @host_check = HostChecker.matching(required_host)
     end
 
     # Public: Gets the full URL for a shortened code.
@@ -44,7 +42,7 @@ module Guillotine
       if resp = check_host(url)
         return resp
       end
-      
+
       begin
         if code = @db.add(url.to_s, code)
           [201, {"Location" => code}]
@@ -70,49 +68,6 @@ module Guillotine
       end
     end
 
-    # Converts the `required_host` argument to a lambda for #check_host.
-    #
-    # host_check - Either a String or Regex limiting which domains the
-    #              shortened URLs can come from.
-    #
-    # Returns nothing.
-    def build_host_check(host_check)
-      case host_check
-      when nil
-        @host_check = NullChecker.new
-      when Regexp
-        build_host_regex_check(host_check)
-      else
-        build_host_string_check(host_check.to_s)
-      end
-    end
-
-    # Builds the host check lambda for regexes.
-    #
-    # regex - The Regexp that limits allowable URL hosts.
-    #
-    # Returns a Lambda that verifies an Addressible::URI.
-    def build_host_regex_check(regex)
-      @host_check = lambda do |url|
-        if url.host.to_s !~ regex
-          [422, {}, "URL must match #{regex.inspect}"]
-        end
-      end
-    end
-
-    # Builds the host check lambda for Strings.
-    #
-    # hostname - The String that limits allowable URL hosts.
-    #
-    # Returns a Lambda that verifies an Addressible::URI.
-    def build_host_string_check(hostname)
-      @host_check = lambda do |url|
-        if url.host != hostname
-          [422, {}, "URL must be from #{hostname}"]
-        end
-      end
-    end
-
     # Ensures that the argument is an Addressable::URI.
     #
     # str - A String URL or an Addressable::URI.

data/test/active_record_adapter_test.rb

@@ -3,7 +3,7 @@ require File.expand_path('../helper', __FILE__)
 begin
   require 'active_record'
   class ActiveRecordAdapterTest < Guillotine::TestCase
-    ADAPTER = Guillotine::Adapters::ActiveRecordAdapter.new :adapter => 'sqlite3', :database => ':memory:'
+    ADAPTER = Guillotine::ActiveRecordAdapter.new :adapter => 'sqlite3', :database => ':memory:'
     ADAPTER.setup
 
     def setup

data/test/app_test.rb

@@ -2,7 +2,7 @@ require File.expand_path('../helper', __FILE__)
 
 module Guillotine
   class AppTest < TestCase
-    ADAPTER = Adapters::MemoryAdapter.new
+    ADAPTER = MemoryAdapter.new
     SERVICE = Service.new(ADAPTER)
     App.set :service, SERVICE
 

data/test/host_checker_test.rb

@@ -0,0 +1,114 @@
+require File.expand_path('../helper', __FILE__)
+
+module Guillotine
+  class MatchingCheckerTest < TestCase
+    def test_regex_checker_is_matched
+      checker = HostChecker.matching(/a/)
+      assert_kind_of RegexHostChecker, checker
+      assert_equal /a/, checker.regex
+    end
+
+    def test_wildcard_checker_is_matched
+      checker = HostChecker.matching('*.foo.com')
+      assert_kind_of WildcardHostChecker, checker
+      assert_equal 'foo.com', checker.host
+    end
+
+    def test_string_checker_is_matched
+      checker = HostChecker.matching('foo.com')
+      assert_kind_of StringHostChecker, checker
+      assert_equal 'foo.com', checker.host
+    end
+
+    def test_hostchecker_matches_self
+      checker = HostChecker.new
+      assert_equal checker, HostChecker.matching(checker)
+    end
+  end
+
+  class CheckerTest < TestCase
+    def test_allows_urls
+      allowed_urls.each do |url|
+        assert_nil checker.call(uri(url)), url
+      end
+    end
+
+    def test_rejects_urls
+      rejected_urls.each do |url|
+        assert res = checker.call(uri(url)), "#{checker.inspect} matched #{url.inspect}"
+        assert_equal 422, res.first, res.inspect
+      end
+    end
+
+    def allowed_urls
+      ['abc']
+    end
+
+    def rejected_urls
+      []
+    end
+
+    def checker
+      @checker ||= build_checker
+    end
+
+    def build_checker
+      HostChecker.new
+    end
+
+    def uri(url)
+      Addressable::URI.parse "http://#{url}"
+    end
+  end
+
+  class WildcardHostCheckerTest < CheckerTest
+    def build_checker
+      WildcardHostChecker.new '*.foo.com'
+    end
+
+    def allowed_urls
+      %w(foo.com foo.com/a abc.foo.com/a)
+    end
+
+    def rejected_urls
+      %w(bar.com foo.com.uk foobcom)
+    end
+
+    def test_parses_host
+      assert_equal 'foo.com', checker.host
+    end
+
+    def test_builds_custom_error
+      assert_match /must be from foo\.com/, checker.error
+    end
+  end
+
+  class StringHostCheckerTest < CheckerTest
+    def build_checker
+      StringHostChecker.new('foo.com')
+    end
+
+    def allowed_urls
+      %w(foo.com foo.com/a)
+    end
+
+    def rejected_urls
+      %w(bar.com)
+    end
+  end
+
+  class RegexHostCheckerTest < CheckerTest
+    def build_checker
+      RegexHostChecker.new(/a/)
+    end
+
+    def allowed_urls
+      %w(abc.com aaa.com)
+    end
+
+    def rejected_urls
+      %w(b.com)
+    end
+  end
+end
+

data/test/memory_adapter_test.rb

@@ -2,7 +2,7 @@ require File.expand_path('../helper', __FILE__)
 
 class MemoryAdapterTest < Guillotine::TestCase
   def setup
-    @db = Guillotine::Adapters::MemoryAdapter.new
+    @db = Guillotine::MemoryAdapter.new
   end
 
   def test_adding_a_link_returns_code