mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/json_pure-1.1.3/lib/json/pure.rb

@@ -0,0 +1,75 @@
+require 'json/common'
+require 'json/pure/parser'
+require 'json/pure/generator'
+
+module JSON
+  begin
+    require 'iconv'
+    # An iconv instance to convert from UTF8 to UTF16 Big Endian.
+    UTF16toUTF8 = Iconv.new('utf-8', 'utf-16be') # :nodoc:
+    # An iconv instance to convert from UTF16 Big Endian to UTF8.
+    UTF8toUTF16 = Iconv.new('utf-16be', 'utf-8') # :nodoc:
+    UTF8toUTF16.iconv('no bom')
+  rescue Errno::EINVAL, Iconv::InvalidEncoding
+    # Iconv doesn't support big endian utf-16. Let's try to hack this manually
+    # into the converters.
+    begin
+      old_verbose, $VERBSOSE = $VERBOSE, nil
+      # An iconv instance to convert from UTF8 to UTF16 Big Endian.
+      UTF16toUTF8 = Iconv.new('utf-8', 'utf-16') # :nodoc:
+      # An iconv instance to convert from UTF16 Big Endian to UTF8.
+      UTF8toUTF16 = Iconv.new('utf-16', 'utf-8') # :nodoc:
+      UTF8toUTF16.iconv('no bom')
+      if UTF8toUTF16.iconv("\xe2\x82\xac") == "\xac\x20"
+        swapper = Class.new do
+          def initialize(iconv) # :nodoc:
+            @iconv = iconv
+          end
+
+          def iconv(string) # :nodoc:
+            result = @iconv.iconv(string)
+            JSON.swap!(result)
+          end
+        end
+        UTF8toUTF16 = swapper.new(UTF8toUTF16) # :nodoc:
+      end
+      if UTF16toUTF8.iconv("\xac\x20") == "\xe2\x82\xac"
+        swapper = Class.new do
+          def initialize(iconv) # :nodoc:
+            @iconv = iconv
+          end
+
+          def iconv(string) # :nodoc:
+            string = JSON.swap!(string.dup)
+            @iconv.iconv(string)
+          end
+        end
+        UTF16toUTF8 = swapper.new(UTF16toUTF8) # :nodoc:
+      end
+    rescue Errno::EINVAL, Iconv::InvalidEncoding
+      raise MissingUnicodeSupport, "iconv doesn't seem to support UTF-8/UTF-16 conversions"
+    ensure
+      $VERBOSE = old_verbose
+    end
+  rescue LoadError
+    raise MissingUnicodeSupport,
+      "iconv couldn't be loaded, which is required for UTF-8/UTF-16 conversions"
+  end
+
+  # Swap consecutive bytes of _string_ in place.
+  def self.swap!(string) # :nodoc:
+    0.upto(string.size / 2) do |i|
+      break unless string[2 * i + 1]
+      string[2 * i], string[2 * i + 1] = string[2 * i + 1], string[2 * i]
+    end
+    string
+  end
+
+  # This module holds all the modules/classes that implement JSON's
+  # functionality in pure ruby.
+  module Pure
+    $DEBUG and warn "Using pure library for JSON."
+    JSON.parser = Parser
+    JSON.generator = Generator
+  end
+end

data/lib/gems/json_pure-1.1.3/lib/json/version.rb

@@ -0,0 +1,9 @@
+module JSON
+  # JSON version
+  VERSION         = '1.1.3'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+  VARIANT_BINARY  = false
+end

data/lib/gems/json_pure-1.1.3/lib/json.rb

@@ -0,0 +1,235 @@
+require 'json/common'
+# = json - JSON for Ruby
+#
+# == Description
+#
+# This is a implementation of the JSON specification according to RFC 4627
+# (http://www.ietf.org/rfc/rfc4627.txt). Starting from version 1.0.0 on there
+# will be two variants available:
+#
+# * A pure ruby variant, that relies on the iconv and the stringscan
+#   extensions, which are both part of the ruby standard library.
+# * The quite a bit faster C extension variant, which is in parts implemented
+#   in C and comes with its own unicode conversion functions and a parser
+#   generated by the ragel state machine compiler
+#   (http://www.cs.queensu.ca/~thurston/ragel).
+#
+# Both variants of the JSON generator escape all non-ASCII an control
+# characters with \uXXXX escape sequences, and support UTF-16 surrogate pairs
+# in order to be able to generate the whole range of unicode code points. This
+# means that generated JSON text is encoded as UTF-8 (because ASCII is a subset
+# of UTF-8) and at the same time avoids decoding problems for receiving
+# endpoints, that don't expect UTF-8 encoded texts. On the negative side this
+# may lead to a bit longer strings than necessarry.
+#
+# All strings, that are to be encoded as JSON strings, should be UTF-8 byte
+# sequences on the Ruby side. To encode raw binary strings, that aren't UTF-8
+# encoded, please use the to_json_raw_object method of String (which produces
+# an object, that contains a byte array) and decode the result on the receiving
+# endpoint.
+#
+# == Author
+#
+# Florian Frank <mailto:flori@ping.de>
+#
+# == License
+#
+# This software is distributed under the same license as Ruby itself, see
+# http://www.ruby-lang.org/en/LICENSE.txt.
+#
+# == Download
+#
+# The latest version of this library can be downloaded at
+#
+# * http://rubyforge.org/frs?group_id=953
+#
+# Online Documentation should be located at
+#
+# * http://json.rubyforge.org
+#
+# == Usage
+# 
+# To use JSON you can
+#   require 'json'
+# to load the installed variant (either the extension 'json' or the pure
+# variant 'json_pure'). If you have installed the extension variant, you can
+# pick either the extension variant or the pure variant by typing
+#   require 'json/ext'
+# or
+#   require 'json/pure'
+#
+# You can choose to load a set of common additions to ruby core's objects if
+# you
+#   require 'json/add/core'
+#
+# After requiring this you can, e. g., serialise/deserialise Ruby ranges:
+#
+#   JSON JSON(1..10) # => 1..10
+#
+# To find out how to add JSON support to other or your own classes, read the
+# Examples section below.
+#
+# To get the best compatibility to rails' JSON implementation, you can
+#   require 'json/add/rails'
+#
+# Both of the additions attempt to require 'json' (like above) first, if it has
+# not been required yet.
+#
+# == Speed Comparisons
+#
+# I have created some benchmark results (see the benchmarks subdir of the
+# package) for the JSON-Parser to estimate the speed up in the C extension:
+#
+# JSON::Pure::Parser::  28.90  calls/second
+# JSON::Ext::Parser::  505.50 calls/second
+#
+# This is ca. <b>17.5</b> times the speed of the pure Ruby implementation.
+#
+# I have benchmarked the JSON-Generator as well. This generates a few more
+# values, because there are different modes, that also influence the achieved
+# speed:
+#
+# * JSON::Pure::Generator:
+#   generate::        35.06 calls/second
+#   pretty_generate:: 34.00 calls/second
+#   fast_generate::   41.06 calls/second
+#
+# * JSON::Ext::Generator:
+#   generate::        492.11 calls/second
+#   pretty_generate:: 348.85 calls/second
+#   fast_generate::   541.60 calls/second
+#
+# * Speedup Ext/Pure:
+#   generate safe::   14.0 times
+#   generate pretty:: 10.3 times
+#   generate fast::   13.2 times
+#
+# The rails framework includes a generator as well, also it seems to be rather
+# slow: I measured only 23.87 calls/second which is slower than any of my pure
+# generator results. Here a comparison of the different speedups with the Rails
+# measurement as the divisor:
+#
+# * Speedup Pure/Rails:
+#   generate safe::   1.5 times
+#   generate pretty:: 1.4 times
+#   generate fast::   1.7 times
+#
+# * Speedup Ext/Rails:
+#   generate safe::   20.6 times
+#   generate pretty:: 14.6 times
+#   generate fast::   22.7 times
+#
+# To achieve the fastest JSON text output, you can use the
+# fast_generate/fast_unparse methods. Beware, that this will disable the
+# checking for circular Ruby data structures, which may cause JSON to go into
+# an infinite loop.
+#
+# == Examples
+#
+# To create a JSON text from a ruby data structure, you
+# can call JSON.generate (or JSON.unparse) like that:
+#
+#  json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+#  # => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
+#
+# To create a valid JSON text you have to make sure, that the output is
+# embedded in either a JSON array [] or a JSON object {}. The easiest way to do
+# this, is by putting your values in a Ruby Array or Hash instance.
+#
+# To get back a ruby data structure from a JSON text, you have to call
+# JSON.parse on it:
+#
+#  JSON.parse json
+#  # => [1, 2, {"a"=>3.141}, false, true, nil, "4..10"]
+# 
+# Note, that the range from the original data structure is a simple
+# string now. The reason for this is, that JSON doesn't support ranges
+# or arbitrary classes. In this case the json library falls back to call
+# Object#to_json, which is the same as #to_s.to_json.
+#
+# It's possible to add JSON support serialization to arbitrary classes by
+# simply implementing a more specialized version of the #to_json method, that
+# should return a JSON object (a hash converted to JSON with #to_json) like
+# this (don't forget the *a for all the arguments):
+#
+#  class Range
+#    def to_json(*a)
+#      {
+#        'json_class'   => self.class.name, # = 'Range'
+#        'data'         => [ first, last, exclude_end? ]
+#      }.to_json(*a)
+#    end
+#  end
+#
+# The hash key 'json_class' is the class, that will be asked to deserialise the
+# JSON representation later. In this case it's 'Range', but any namespace of
+# the form 'A::B' or '::A::B' will do. All other keys are arbitrary and can be
+# used to store the necessary data to configure the object to be deserialised.
+#
+# If a the key 'json_class' is found in a JSON object, the JSON parser checks
+# if the given class responds to the json_create class method. If so, it is
+# called with the JSON object converted to a Ruby hash. So a range can
+# be deserialised by implementing Range.json_create like this:
+# 
+#  class Range
+#    def self.json_create(o)
+#      new(*o['data'])
+#    end
+#  end
+#
+# Now it possible to serialise/deserialise ranges as well:
+#
+#  json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+#  # => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]"
+#  JSON.parse json
+#  # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+#
+# JSON.generate always creates the shortest possible string representation of a
+# ruby data structure in one line. This good for data storage or network
+# protocols, but not so good for humans to read. Fortunately there's also
+# JSON.pretty_generate (or JSON.pretty_generate) that creates a more
+# readable output:
+#
+#  puts JSON.pretty_generate([1, 2, {"a"=>3.141}, false, true, nil, 4..10])
+#  [
+#    1,
+#    2,
+#    {
+#      "a": 3.141
+#    },
+#    false,
+#    true,
+#    null,
+#    {
+#      "json_class": "Range",
+#      "data": [
+#        4,
+#        10,
+#        false
+#      ]
+#    }
+#  ]
+#
+# There are also the methods Kernel#j for unparse, and Kernel#jj for
+# pretty_unparse output to the console, that work analogous to Core Ruby's p
+# and the pp library's pp methods.
+#
+# The script tools/server.rb contains a small example if you want to test, how
+# receiving a JSON object from a webrick server in your browser with the
+# javasript prototype library (http://www.prototypejs.org) works.
+#
+module JSON
+  require 'json/version'
+
+  if VARIANT_BINARY
+    require 'json/ext'
+  else
+    begin
+      require 'json/ext'
+    rescue LoadError
+      require 'json/pure'
+    end
+  end
+
+  JSON_LOADED = true
+end

data/lib/gems/launchy-0.3.2/bin/launchy

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+begin
+    require 'launchy'
+rescue LoadError 
+    path = File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+    raise if $:.include? path
+    $: << path
+    retry
+end
+
+Launchy.command_line.run(ARGV)

data/lib/gems/launchy-0.3.2/lib/launchy/application.rb

@@ -0,0 +1,163 @@
+require 'rbconfig'
+
+module Launchy
+    class Application
+        
+        KNOWN_OS_FAMILIES = [ :windows, :darwin, :nix, :cygwin ]
+        
+        class << self
+            def inherited(sub_class)
+                application_classes << sub_class
+            end            
+            def application_classes
+                @application_classes ||= []
+            end                
+            
+            def find_application_class_for(*args)
+                Launchy.log "#{self.name} : finding application classes for [#{args.join(' ')}]"
+                application_classes.find do |klass| 
+                    Launchy.log "#{self.name} : Trying #{klass.name}"
+                    if klass.handle?(*args) then
+                        true
+                    else
+                        false
+                    end
+                end
+            end
+            
+           # find an executable in the available paths
+            # mkrf did such a good job on this I had to borrow it.
+            def find_executable(bin,*paths)
+                paths = ENV['PATH'].split(File::PATH_SEPARATOR) if paths.empty?
+                paths.each do |path|
+                    file = File.join(path,bin)
+                    if File.executable?(file) then
+                        Launchy.log "#{self.name} : found executable #{file}"
+                        return file
+                    end
+                end
+                Launchy.log "#{self.name} : Unable to find `#{bin}' in #{paths.join(', ')}"
+                return nil
+            end
+            
+            # return the current 'host_os' string from ruby's configuration
+            def my_os
+                if ENV['LAUNCHY_HOST_OS'] then 
+                    Launchy.log "#{self.name} : Using LAUNCHY_HOST_OS override of '#{ENV['LAUNCHY_HOST_OS']}'"
+                    return ENV['LAUNCHY_HOST_OS']
+                else
+                    ::Config::CONFIG['host_os']
+                end
+            end
+        
+            # detect what the current os is and return :windows, :darwin or :nix
+            def my_os_family(test_os = my_os)
+                case test_os
+                when /mingw/i
+                    family = :windows
+                when /mswin/i
+                    family = :windows
+                when /windows/i
+                    family = :windows
+                when /darwin/i
+                    family = :darwin
+                when /mac os/i
+                    family = :darwin
+                when /solaris/i
+                    family = :nix
+                when /bsd/i
+                    family = :nix
+                when /linux/i
+                    family = :nix
+                when /aix/i
+                    family = :nix
+                when /cygwin/i
+                    family = :cygwin
+                else
+                    $stderr.puts "Unknown OS familiy for '#{test_os}'.  Please report this bug to #{Launchy::SPEC.email}"
+                    family = :unknown
+                end
+            end
+        end
+
+
+        # Determine the appropriate desktop environment for *nix machine.  Currently this is
+        # linux centric.  The detection is based upon the detection used by xdg-open from 
+        # http://portland.freedesktop.org/wiki/XdgUtils
+        def nix_desktop_environment
+            if not @nix_desktop_environment then
+                @nix_desktop_environment = :generic
+                if ENV["KDE_FULL_SESSION"] || ENV["KDE_SESSION_UID"] then
+                    @nix_desktop_environment = :kde
+                elsif ENV["GNOME_DESKTOP_SESSION_ID"] then
+                    @nix_desktop_environment = :gnome
+                elsif find_executable("xprop") then
+                    if %x[ xprop -root _DT_SAVE_MODE | grep ' = \"xfce\"$' ].strip.size > 0 then
+                        @nix_desktop_environment = :xfce
+                    end
+                end
+                Launchy.log "#{self.class.name} : nix_desktop_environment => '#{@nix_desktop_environment}'"
+            end
+            return @nix_desktop_environment
+        end
+        
+        # find an executable in the available paths
+        def find_executable(bin,*paths)
+            Application.find_executable(bin,*paths)
+        end
+        
+        # return the current 'host_os' string from ruby's configuration
+        def my_os
+            Application.my_os
+        end
+        
+        # detect what the current os is and return :windows, :darwin, :nix, or :cygwin
+        def my_os_family(test_os = my_os)
+            Application.my_os_family(test_os)
+        end
+        
+        # returns the list of command line application names for the current os.  The list 
+        # returned should only contain appliations or commands that actually exist on the
+        # system.  The list members should have their full path to the executable.
+        def app_list
+            @app_list ||= self.send("#{my_os_family}_app_list")
+        end
+                
+        # On darwin a good general default is the 'open' executable.
+        def darwin_app_list
+            Launchy.log "#{self.class.name} : Using 'open' application on darwin."
+            [ find_executable('open') ]
+        end
+        
+        # On windows a good general default is the 'start' Command Shell command
+        def windows_app_list
+            Launchy.log "#{self.class.name} : Using 'start' command on windows."
+            %w[ start ]
+        end
+        
+        # Cygwin uses the windows start but through an explicit execution of the cmd shell
+        def cygwin_app_list
+            Launchy.log "#{self.class.name} : Using 'cmd /C start' on windows."
+            [ "cmd /C start" ]
+        end
+        
+        # run the command
+        def run(cmd,*args)
+            args.unshift(cmd)
+            cmd_line = args.join(' ')
+            Launchy.log "#{self.class.name} : Spawning on #{my_os_family} : #{cmd_line}"
+            
+            if my_os_family == :windows then
+                system cmd_line
+            else
+                # fork, and the child process should NOT run any exit handlers
+                child_pid = fork do 
+                                cmd_line += " > /dev/null 2>&1"
+                                system cmd_line
+                                exit! 
+                            end
+                Process.detach(child_pid)
+            end
+        end
+    end
+end

data/lib/gems/launchy-0.3.2/lib/launchy/browser.rb

@@ -0,0 +1,85 @@
+require 'launchy/application'
+require 'uri'
+
+module Launchy
+    class Browser < Application
+        
+        DESKTOP_ENVIRONMENT_BROWSER_LAUNCHERS = {
+            :kde     => "kfmclient",
+            :gnome   => "gnome-open",
+            :xfce    => "exo-open",
+            :generic => "htmlview"
+        }
+        
+        FALLBACK_BROWSERS = %w[ firefox seamonkey opera mozilla netscape galeon ]
+        
+        class << self
+            def run(*args)
+                Browser.new.visit(args[0]) 
+            end
+            
+            # return true if this class can handle the given parameter(s)
+            def handle?(*args)
+                begin 
+                    Launchy.log "#{self.name} : testing if [#{args[0]}] (#{args[0].class}) is a url."
+                    uri = URI.parse(args[0])
+                    result =  [URI::HTTP, URI::HTTPS, URI::FTP].include?(uri.class)
+                rescue Exception => e
+                    # hmm... why does rcov not see that this is executed ?
+                    Launchy.log "#{self.name} : not a url, #{e}" 
+                    return false
+                end
+            end
+        end
+        
+        def initialize
+            raise "Unable to find browser to launch for os family '#{my_os_family}'." unless browser
+        end                        
+            
+        # Find a list of potential browser applications to run on *nix machines.  
+        # The order is:
+        #     1) What is in ENV['LAUNCHY_BROWSER'] or ENV['BROWSER']
+        #     2) xdg-open
+        #     3) desktop environment launcher program
+        #     4) a list of fallback browsers
+        def nix_app_list
+            if not @nix_app_list then
+                browser_cmds = ['xdg-open']
+                browser_cmds << DESKTOP_ENVIRONMENT_BROWSER_LAUNCHERS[nix_desktop_environment]
+                browser_cmds << FALLBACK_BROWSERS
+                browser_cmds.flatten!
+                browser_cmds.delete_if { |b| b.nil? || (b.strip.size == 0) }
+                Launchy.log "#{self.class.name} : Initial *Nix Browser List: #{browser_cmds.join(', ')}"
+                @nix_app_list = browser_cmds.collect { |bin| find_executable(bin) }.find_all { |x| not x.nil? }
+                Launchy.log "#{self.class.name} : Filtered *Nix Browser List: #{@nix_app_list.join(', ')}"
+            end
+            @nix_app_list
+        end
+                                
+        # return the full command line path to the browser or nil
+        def browser
+            if not @browser then
+                if ENV['LAUNCHY_BROWSER'] and File.exists?(ENV['LAUNCHY_BROWSER']) then
+                    Launchy.log "#{self.class.name} : Using LAUNCHY_BROWSER environment variable : #{ENV['LAUNCHY_BROWSER']}"
+                    @browser = ENV['LAUNCHY_BROWSER']
+                elsif ENV['BROWSER'] and File.exists?(ENV['BROWSER']) then
+                    Launchy.log "#{self.class.name} : Using BROWSER environment variable : #{ENV['BROWSER']}"
+                    @browser = ENV['BROWSER']
+                elsif app_list.size > 0 then
+                    @browser = app_list.first
+                    Launchy.log "#{self.class.name} : Using application list : #{@browser}"
+                else
+                    msg = "Unable to launch. No Browser application found."
+                    Launchy.log "#{self.class.name} : #{msg}"
+                    $stderr.puts msg
+                end
+            end
+            return @browser
+        end
+        
+        # launch the browser at the appointed url
+        def visit(url)
+            run(browser,url)
+        end
+    end
+end

data/lib/gems/launchy-0.3.2/lib/launchy/command_line.rb

@@ -0,0 +1,48 @@
+require 'optparse'
+
+module Launchy
+    class CommandLine
+
+        def parser
+            @parser ||= OptionParser.new do |op|
+                            op.banner = "Usage: launchy [options] url"
+                            op.separator ""
+                            op.on("-d", "--debug", "Force debug, output lots of information.",
+                                        "This sets the LAUNCHY_DEBUG environment variable to 'true'.") do |d|
+                                ENV["LAUNCHY_DEBUG"] = 'true'
+                            end
+                        
+                            op.on("-h", "--help", "Print this message") do |h|
+                                puts op.to_s
+                                exit 0
+                            end
+
+                            op.on("-v", "--version", "Output the version of Launchy") do |v|
+                                puts "Launchy version #{Launchy::VERSION}"
+                                exit 0
+                            end
+                        
+                            op.on("-o", "--host-os HOST_OS","Force the behavior of a particular host os.",
+                                    "This sets the LAUNCHY_HOST_OS environment variable.") do |os|
+                                ENV["LAUNCHY_HOST_OS"] = os
+                            end
+                            
+                            op.on("-b", "--browser BROWSER", "Force launchy to use a particular browser.",
+                                   "This sets the LAUNCHY_BROWSER environment variable.") do |browser|
+                                ENV["LAUNCHY_BROWSER"] = browser
+                            end
+                      end
+        end
+        
+        def run(argv = ARGV)
+            begin 
+                parser.parse!(argv)
+                Launchy.open(*argv)
+            rescue ::OptionParser::ParseError => pe
+                $stderr.puts "#{parser.programn_name}: #{pe}"
+                $stderr.puts "Try `#{parser.program_name} --help' for more information."
+                exit 1
+            end
+        end
+    end
+end

data/lib/gems/launchy-0.3.2/lib/launchy/gemspec.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'launchy/specification'
+require 'launchy/version'
+require 'rake'
+
+# The Gem Specification plus some extras for launchy.
+module Launchy
+    SPEC = Launchy::Specification.new do |spec|
+                spec.name               = "launchy"
+                spec.version            = Launchy::VERSION
+                spec.rubyforge_project  = "copiousfreetime"
+                spec.author             = "Jeremy Hinegardner"
+                spec.email              = "jeremy@hinegardner.org"
+                spec.homepage           = "http://copiousfreetime.rubyforge.org/launchy/"
+
+                spec.summary            = "A helper to launch apps from within ruby programs."
+                spec.description        = <<-DESC
+                Launchy is helper class for launching cross-platform applications in a
+                fire and forget manner.  
+
+                There are application concepts (browser, email client, etc) that are common
+                across all platforms, and they may be launched differently on each
+                platform.  Launchy is here to make a common approach to launching
+                external application from within ruby programs.
+                
+                DESC
+
+                spec.extra_rdoc_files   = FileList["CHANGES", "LICENSE", "README"]
+                spec.has_rdoc           = true
+                spec.rdoc_main          = "README"
+                spec.rdoc_options       = [ "--line-numbers" , "--inline-source" ]
+
+                spec.test_files         = FileList["spec/**/*.rb", "test/**/*.rb"]
+                spec.files              = spec.test_files + spec.extra_rdoc_files + 
+                                          FileList["lib/**/*.rb", "resources/**/*"]
+                
+                spec.executable         = spec.name
+
+                spec.platform           = Gem::Platform::RUBY
+                spec.required_ruby_version  = ">= 1.8.5"
+
+                spec.local_rdoc_dir     = "doc/rdoc"
+                spec.remote_rdoc_dir    = ""
+                spec.local_coverage_dir = "doc/coverage"
+                spec.remote_coverage_dir= "coverage"
+
+                spec.remote_user        = "jjh"
+                spec.remote_site_dir    = "#{spec.name}/"
+
+           end
+end
+
+