eymiha_url 1.0.0

data/gem_package.rb

@@ -0,0 +1,31 @@
+class GemPackage
+  
+  attr_reader :name, :version, :files
+  
+  def initialize
+    @name = 'eymiha_url'
+    @version = '1.0.0'
+    @files = FileList[
+      '*.rb',
+      'lib/**/*',
+      'test/*',
+      'html/**/*'
+    ]
+  end
+
+  def fill_spec(s)
+    s.name = name
+    s.version = version
+    s.summary = "Eymiha application url features"
+    s.files = files.to_a
+    s.require_path = 'lib'
+    s.autorequire = name
+    s.has_rdoc = true
+    s.rdoc_options << "--all"
+    s.author = "Dave Anderson"
+    s.email = "dave@eymiha.com"
+    s.homepage = "http://www.eymiha.com"
+    s.rubyforge_project = "cori"
+  end
+
+end

data/lib/eymiha/url/url_exception.rb

@@ -0,0 +1,7 @@
+module Eymiha
+
+  # Raised when a problem has occured when normalizing or opening a URL.
+  class UrlException < Exception
+  end
+
+end

data/lib/eymiha/url/url_normalizer.rb

@@ -0,0 +1,105 @@
+require 'uri'
+
+require 'eymiha/url/url_exception'
+
+module Eymiha
+
+  # A UrlNormalizer normalizes URLs. They are validated using the URI class
+  # except when they can be identified as file resources. When so, if the
+  # designated file's name starts with a slash (or a drive identifier
+  # followed by a slash on a windows box) the path is used verbatim. If not,
+  # the named file is assumed to be relative to a caller-supplied base
+  # directory.
+  class UrlNormalizer
+    
+    @@using_pc_filesystem = Config::CONFIG['target_vendor'] == "pc"
+    
+    @@relative_base = nil
+    
+    # Returns true if the given relative_base is valid. It should start and
+    # end with a slash (or start with a drive designator and a slash and end
+    # with a slash on a PC).
+    def self.valid_relative_base? relative_base
+      ((@@using_pc_filesystem and (relative_base =~ /^[A-Za-z]:\//)) or
+       (!@@using_pc_filesystem and (relative_base =~ /^\//))) and
+        (relative_base =~ /\/$/)
+    end
+    
+    # Sets and returns the default directory for normalizing relative file
+    # resources. The directory is validated prior to assignment - if invalid
+    # a UrlException will be raised.
+    def self.relative_base=(relative_base)
+      if valid_relative_base? relative_base
+        @@relative_base = relative_base
+      else
+        raise UrlException, "Invalid relative file base '#{relative_base}'"
+      end
+    end
+    
+    # Returns the default directory for normalizing relative file resources.
+    def self.relative_base
+      @@relative_base
+    end
+    
+    attr_reader :relative_base
+    
+    # Creates a new instance using the default direcory for normalizing
+    # relative file resources.
+    def initialize()
+      @relative_base = @@relative_base
+    end
+    
+    # Returns a normalized URL relative to the given base if it is a
+    # relative file resource.
+    def normalize(url,relative_base=nil)
+      self.relative_base = relative_base if relative_base
+      (self.class.file_url? url) ? normalize_file(url) : URI.parse(url).to_s
+    end
+    
+    # Returns true if the given URL is a file resource.
+    def self.file_url? url
+      (url =~ /^file:/) or
+        (url =~ /^\//) or
+        ((url =~ /^[A-Za-z]:/) and @@using_pc_filesystem) or
+        !(url =~ /:/)
+    end
+    
+    # Normalizes and returns a relative or absolute URL file resource.
+    def normalize_file file_url
+      "file://#{normalize_file_path((file_url =~ /file:\/\//) ? $' : file_url)}"
+    end
+    
+    # Sets and Returns the directory for normalizing relative file resources.
+    # The directory is validated prior to assignment - if invalid a
+    # UrlException will be raised.
+    def relative_base=(relative_base)
+      if self.class.valid_relative_base? relative_base
+        @relative_base = relative_base
+      else
+        raise UrlException, "Invalid relative file base '#{relative_base}'"
+      end
+    end
+    
+    # Returns true if the given URL file resource is absolute.
+    def self.absolute_file_path? file_url
+      @@using_pc_filesystem ?
+      (file_url =~ /^[A-Za-z]:\//) :
+        (!(file_url =~ /^[A-Za-z]:/) and (file_url =~ /^\//))
+    end
+    
+    # Returns an absolute path for the given URL file resource. This is either
+    # the incoming URL if absolute, or the URL anchored at the relative base
+    # if relative.
+    def normalize_file_path file_url
+      if self.class.absolute_file_path? file_url
+        file_url
+      elsif @relative_base != nil
+        "#{relative_base}#{file_url}"
+      else
+        raise UrlException, "no relative file base was configured"
+      end
+    end
+    
+  end
+    
+end

data/lib/eymiha/url/url_opener.rb

@@ -0,0 +1,141 @@
+require 'eymiha'
+require 'eymiha/url/url_exception'
+require 'eymiha/url/url_normalizer'
+
+optional_require 'win32/registry'
+
+module Eymiha
+  
+  # UrlOpener opens a URL in a user's URL viewer of choice. URLs are
+  # normalized prior to being opened.
+  #
+  # Instances use the Kernel::system method to open the resource in its
+  # own Thread to avoid blocking. Any problems are raised through a
+  # caller-supplied exception handler's handle(Exception) method.
+  #
+  # For Apple and Windows, the viewer-of-choice is defaulted to the user's
+  # designated viewer in the environment. For other platforms, the caller
+  # must assign the viewer prior to opening the URL.
+  class UrlOpener
+    
+    @@url_viewer = nil
+    
+    # Sets and returns the user's default URL viewer-or-choice.
+    def self.url_viewer=(url_viewer)
+      @@url_viewer = url_viewer
+    end
+    
+    # Returns the user's default URL viewer-of-choice.
+    def self.url_viewer
+      @@url_viewer
+    end
+    
+    @@relative_base = nil
+    
+    # Sets and returns the default directory for opening relative file
+    # resources. The directory is validated prior to assignment - if invalid
+    # a UrlException will be raised.
+    def self.relative_base=(relative_base)
+      if UrlNormalizer.valid_relative_base? relative_base
+        @@relative_base = relative_base
+      else
+        raise UrlException, "Invalid relative file base '#{relative_base}'"
+      end
+    end
+    
+    # Returns the default directory for opening relative file resources.
+    def self.relative_base
+      @@relative_base
+    end
+    
+    @@exception_handler = nil
+    
+    # Sets and returns the default exception handler. Problems are reported
+    # through its handle method, so it should either have the method, or
+    # construct it or delegate at runtime.
+    def self.exception_handler=(exception_handler)
+      @@exceptionHandler = exception_handler
+    end
+    
+    # Returns the default exception handler.
+    def self.exception_handler
+      @@exception_handler
+    end
+    
+    attr_accessor :url_viewer, :exception_handler
+    attr_reader :relative_base
+    
+    # Constructs and returns a new instance, using the default exception
+    # handler, directory for opening relative file resources, and viewer of
+    # choice.
+    def initialize(exception_handler=@@exception_handler,
+                   relative_base=@@relative_base,
+                   url_viewer=@@url_viewer)
+      @exception_handler = exception_handler
+      @relative_base = relative_base
+      @url_viewer = url_viewer
+      @url_normalizer = UrlNormalizer.new
+    end
+    
+    # Sets and Returns the directory for opening relative file resources. The
+    # directory is validated prior to assignment - if invalid a UrlException
+    # will be raised.
+    def relative_base=(relative_base)
+      if UrlNormalizer.valid_relative_base? relative_base
+        @relative_base = relative_base
+      else
+        raise UrlException, "Invalid relative file base '#{relative_base}'"
+      end
+    end
+    
+    # opens the given URL in the user's viewer of choice. The method uses a
+    # separate Thread to avoid blocking. Local file resources are opened
+    # relative to the value of the current relative base directory, and any
+    # problems are reported through the exception handler.
+    def open url
+      Thread.new {
+        begin
+          send "open_#{Config::CONFIG['target_vendor']}".to_sym,
+          @url_normalizer.normalize(url.to_s,@relative_base)
+        rescue Exception => exception
+          @exception_handler.handle exception
+        end
+        terminate
+      }
+    end
+    
+    def method_missing(method,*args)
+      open_other(*args) if method.to_s =~ /^open_/
+    end
+    
+    private
+    
+    def open_apple url
+      system "#{url_viewer||"open"} #{url}"
+    end
+    
+    def windows_browser
+      @@windows_browser ||=
+        Win32::Registry::HKEY_CLASSES_ROOT.
+        open('htmlfile\shell\open\command') { |reg|
+        reg_type, reg_value = reg.read('')
+        return reg_value
+      }
+    end
+    
+    def open_pc url
+      system "#{url_viewer||windows_browser} #{url}"
+    end
+    
+    def open_other *args
+      if @url_viewer
+        system "#{@url_viewer} #{args.join(' ')}"
+      else
+        raise UrlException,
+        "No program was designated to open the URL."
+      end
+    end
+    
+  end
+  
+end

data/lib/eymiha/url.rb

@@ -0,0 +1,4 @@
+# Adds the URL-aware classes.
+require 'eymiha/url/url_exception'
+require 'eymiha/url/url_normalizer'
+require 'eymiha/url/url_opener'

data/rakefile.rb

@@ -0,0 +1,2 @@
+require 'gem_package'
+require 'gem_raker'

data/test/tc_url_normalizer.rb

@@ -0,0 +1,143 @@
+require 'test/unit'
+
+require 'eymiha/url'
+
+
+class TC_url_normalizer < Test::Unit::TestCase
+  
+  include Eymiha
+  
+  def test_absolute_file_path
+
+    UrlNormalizer.using_pc_filesystem = true   # pc tests
+    assert(  UrlNormalizer.absolute_file_path?("c:/foo/bar"))
+    assert(! UrlNormalizer.absolute_file_path?("c:bar"))
+    assert(! UrlNormalizer.absolute_file_path?("/foo/bar"))
+    assert(! UrlNormalizer.absolute_file_path?("bar"))
+    
+    UrlNormalizer.using_pc_filesystem = false  # non-pc-tests
+    assert(! UrlNormalizer.absolute_file_path?("c:/foo/bar"))
+    assert(! UrlNormalizer.absolute_file_path?("c:bar"))
+    assert(  UrlNormalizer.absolute_file_path?("/foo/bar"))
+    assert(! UrlNormalizer.absolute_file_path?("bar"))
+    
+  end
+  
+  def test_valid_relative_base
+    
+    UrlNormalizer.using_pc_filesystem = true   # pc tests
+    assert(  UrlNormalizer.valid_relative_base?("c:/foo/"))
+    assert(! UrlNormalizer.valid_relative_base?("/foo/"))
+    assert(! UrlNormalizer.valid_relative_base?("c:/foo"))
+    assert(! UrlNormalizer.valid_relative_base?("/foo"))    
+    assert(  UrlNormalizer.valid_relative_base?("c:/"))
+    assert(! UrlNormalizer.valid_relative_base?("/"))
+    
+    UrlNormalizer.using_pc_filesystem = false  # non-pc-tests
+    assert(! UrlNormalizer.valid_relative_base?("c:/foo/"))
+    assert(  UrlNormalizer.valid_relative_base?("/foo/"))
+    assert(! UrlNormalizer.valid_relative_base?("c:/foo"))
+    assert(! UrlNormalizer.valid_relative_base?("/foo"))    
+    assert(! UrlNormalizer.valid_relative_base?("c:/"))
+    assert(  UrlNormalizer.valid_relative_base?("/"))
+    
+  end
+  
+  def test_file_url
+    
+    UrlNormalizer.using_pc_filesystem = true   # pc tests
+    assert(  UrlNormalizer.file_url?("file://foo/bar"))
+    assert(  UrlNormalizer.file_url?("/foo/bar"))
+    assert(  UrlNormalizer.file_url?("c:foo"))
+    assert(  UrlNormalizer.file_url?("foo"))
+    assert(! UrlNormalizer.file_url?("bump:mumble"))
+    
+    UrlNormalizer.using_pc_filesystem = false  # non-pc-tests
+    assert(  UrlNormalizer.file_url?("file://foo/bar"))
+    assert(  UrlNormalizer.file_url?("/foo/bar"))
+    assert(! UrlNormalizer.file_url?("c:foo"))
+    assert(  UrlNormalizer.file_url?("foo"))
+    assert(! UrlNormalizer.file_url?("bump:mumble"))
+    
+  end
+  
+  def test_normalize
+    
+    urlNormalizer = UrlNormalizer.new
+    
+    UrlNormalizer.using_pc_filesystem = true   # pc tests
+    urlNormalizer.relative_base = "c:/foo/"
+    assert(urlNormalizer.normalize("file://c:/foo/bar") == "file://c:/foo/bar")
+    assert(urlNormalizer.normalize("c:/foo/bar") == "file://c:/foo/bar")
+    assert(urlNormalizer.normalize("file://bar") == "file://c:/foo/bar")
+    assert(urlNormalizer.normalize("bar") == "file://c:/foo/bar")
+    assert(urlNormalizer.normalize("bump:mumble") == "bump:mumble")
+ 
+    UrlNormalizer.using_pc_filesystem = false  # non-pc-tests
+    urlNormalizer.relative_base = "/foo/"
+    assert(urlNormalizer.normalize("file:///foo/bar") == "file:///foo/bar")
+    assert(urlNormalizer.normalize("/foo/bar") == "file:///foo/bar")
+    assert(urlNormalizer.normalize("file://bar") == "file:///foo/bar")
+    assert(urlNormalizer.normalize("bar") == "file:///foo/bar")
+    assert(urlNormalizer.normalize("bump:mumble") == "bump:mumble")
+    
+  end
+  
+  def test_normalize_file
+    
+    urlNormalizer = UrlNormalizer.new
+    
+    UrlNormalizer.using_pc_filesystem = true   # pc tests
+    urlNormalizer.relative_base = "c:/foo/"
+    assert(urlNormalizer.normalize_file("file://c:/foo/bar") == "file://c:/foo/bar")
+    assert(urlNormalizer.normalize_file("c:/foo/bar") == "file://c:/foo/bar")
+    assert(urlNormalizer.normalize_file("file://bar") == "file://c:/foo/bar")
+    assert(urlNormalizer.normalize_file("bar") == "file://c:/foo/bar")
+    
+    UrlNormalizer.using_pc_filesystem = false  # non-pc-tests
+    urlNormalizer.relative_base = "/foo/"
+    assert(urlNormalizer.normalize_file("file:///foo/bar") == "file:///foo/bar")
+    assert(urlNormalizer.normalize_file("/foo/bar") == "file:///foo/bar")
+    assert(urlNormalizer.normalize_file("file://bar") == "file:///foo/bar")
+    assert(urlNormalizer.normalize_file("bar") == "file:///foo/bar")
+    
+  end
+  
+  def test_normalize_file_path
+
+    urlNormalizer = UrlNormalizer.new
+    assert_raise(UrlException) { urlNormalizer.normalize_file_path("bar") }
+    
+    UrlNormalizer.using_pc_filesystem = true   # pc tests
+    urlNormalizer.relative_base = "c:/foo/"
+    assert(urlNormalizer.normalize_file_path("c:/foo/bar") == "c:/foo/bar")
+    assert(urlNormalizer.normalize_file_path("bar") == "c:/foo/bar")
+    
+    UrlNormalizer.using_pc_filesystem = false  # non-pc-tests
+    urlNormalizer.relative_base = "/foo/"
+    assert(urlNormalizer.normalize_file_path("/foo/bar") == "/foo/bar")
+    assert(urlNormalizer.normalize_file_path("bar") == "/foo/bar")
+    
+  end
+
+  def test_relative_base
+
+    assert_raise(UrlException) { UrlNormalizer.relative_base = ""}
+
+    urlNormalizer = UrlNormalizer.new
+    assert_raise(UrlException) { urlNormalizer.relative_base = ""}
+
+  end
+  
+end
+
+
+# just for testing...
+
+class Eymiha::UrlNormalizer
+  
+  def self.using_pc_filesystem=(using_pc_filesystem)
+    @@using_pc_filesystem = using_pc_filesystem
+  end
+
+end

data/test/tc_url_opener.rb

@@ -0,0 +1,75 @@
+require 'eymiha/test'
+require 'eymiha/url'
+
+
+class TC_url_opener < Test::Unit::TestCase
+
+  # exception_handler is tested indirectly
+  # relative_base is tested in UrlNormalizer
+  # method_missing is tested indirectly
+  # windows registry access is assumed correct
+  
+  include Eymiha
+
+  def test_open_apple
+    url_opener = UrlOpener.new
+    probe UrlOpener, :open_apple do
+      assert(url_opener.open_apple("foo") == "open foo")
+    end
+    url_opener.url_viewer = "url_viewer"
+    probe UrlOpener, :open_apple do
+      assert(url_opener.open_apple("foo") == "url_viewer foo")
+    end
+  end
+
+  def test_open_pc
+    url_opener = UrlOpener.new
+    UrlOpener.windows_browser = "windows_browser"
+    probe UrlOpener, :open_pc do
+      assert(url_opener.open_pc("foo") == "windows_browser foo")
+    end
+    url_opener.url_viewer = "url_viewer"
+    probe UrlOpener, :open_pc do
+      assert(url_opener.open_pc("foo") == "url_viewer foo")
+    end
+  end
+
+  def test_open_other
+    url_opener = UrlOpener.new(self,nil,nil)
+    probe UrlOpener, :open_other do
+      assert_raise(UrlException) { url_opener.open_foo }
+    end
+    url_opener.url_viewer = "url_viewer"
+    probe UrlOpener, :open_other do
+        assert(url_opener.open_other("foo") == "url_viewer foo")
+    end
+  end
+  
+end
+
+
+# just for testing...
+
+class Eymiha::UrlOpener
+  
+  def system(command)
+    command
+  end
+
+  def url_normalizer=(url_normalizer)
+    @url_normalizer = url_normalizer
+  end
+
+  def normalize(url,relative_base)
+    url
+  end
+
+  def self.windows_browser=(windows_browser)
+    @@windows_browser = windows_browser
+  end
+
+  def handle
+    raise UrlException
+  end
+
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: eymiha_url
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2008-05-07 00:00:00 -04:00
+summary: Eymiha application url features
+require_paths: 
+- lib
+email: dave@eymiha.com
+homepage: http://www.eymiha.com
+rubyforge_project: cori
+description: 
+autorequire: eymiha_url
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Dave Anderson
+files: 
+- gem_package.rb
+- rakefile.rb
+- lib/eymiha
+- lib/eymiha/url
+- lib/eymiha/url/url_exception.rb
+- lib/eymiha/url/url_normalizer.rb
+- lib/eymiha/url/url_opener.rb
+- lib/eymiha/url.rb
+- test/tc_url_normalizer.rb
+- test/tc_url_opener.rb
+test_files: []
+
+rdoc_options: 
+- --all
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+