minep-request 0.0.3 → 0.0.4

data/.gitignore

@@ -0,0 +1,20 @@
+*.dev.rb
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+archives
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in minep-request.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matthieu "Ezveus" Ciappara
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,17 +1,63 @@
-minep-request
-=============
+# minep-request
 
-minep-request is a ruby gem allowing to communicate with a [MINE server](http://github.com/Ezveus/Mine)
+minep-request is a binary allowing to communicate with a [MINE
+server](http://github.com/Ezveus/Mine).
 
-  Requests are AUTHENTICATE, SIGNUP, EXEC, INSERT, MOVE, BACKSPACE and DELETE.
+It uses MINE Protocol over TCP using Ruby Standard Sockets or over
+WebSocket Protocol using
+[WEBSocket](https://rubygems.org/gems/WEBSocket).
 
-Arguments required :
---------------------
+It works as an interactive 'shell' reading some commands (or requests
+arguments) on the standard input and sends valid MINEP requests to the
+server.
 
-- AUTHENTICATE : *name* and *pass*
-- SIGNUP : *name*, *pass*, *email* and (optionaly) *website*
-- EXEC : Not implemented yet
-- INSERT : Not implemented yet
-- MOVE : Not implemented yet
-- BACKSPACE : Not implemented yet
-- DELETE : Not implemented yet
+The known commands are :
+- authenticate : Send an AUTHENTICATE request
+- backspace : Send a BACKSPACE request
+- delete : Send a DELETE request
+- exec : Send an EXEC request
+- exit : Disconnect and quit the program
+- help : Show the list of the commands
+- insert : Send an INSERT request
+- move : Send a MOVE request
+- quit : Disconnect and quit the program
+- signup : Send a SIGNUP request
+
+Without arguments, the default communication type is TCP trying to
+connect to localhost on port 8080 (default MINE over TCP port). See
+the [usage](#usage) to change the host, port or communication type.
+
+If the communication type is WebSocket and no port is given, the port
+is updated to Mine over WebSocket default port (8081).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'minep-request'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install minep-request
+
+## <div id="usage">Usage</div>
+
+Usage: mine-request [OPTIONS]
+Send a request to a MINE server
+    -h, --host HOST                  server hostname
+    -p, --port PORT                  server port
+    -t, --type TYPE                  type of communication (tcp |
+    websocket)
+        --help                       displays this screen
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/mine-request

@@ -1,32 +1,65 @@
 #!/usr/bin/env ruby
 
+# lib = "lib"
+# $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
 require 'optparse'
-require 'rubygems'
-require 'minep'
+require 'socket'
+require 'WEBSocket'
+require 'minep-request'
+
+$options = {
+  :host => "localhost",
+  :port => 8080,
+  :type => :tcp
+}
+$goon = true
+
+$commands = {
+  "authenticate" => Proc.new { |s| Minep::Request.authenticate s},
+  "signup" => Proc.new { |s| Minep::Request.signup s},
+  "exec" => Proc.new { |s| Minep::Request.exec s},
+  "insert" => Proc.new { |s| Minep::Request.insert s},
+  "move" => Proc.new { |s| Minep::Request.move s},
+  "backspace" => Proc.new { |s| Minep::Request.backspace s},
+  "delete" => Proc.new { |s| Minep::Request.delete s},
+  "file" => Proc.new { |s| Minep::Request.file s},
+  "help" => Proc.new { |s| help s},
+  "exit" => Proc.new { |s| quit s},
+  "quit" => Proc.new { |s| quit s}
+}
+
+def quit socket = nil
+  $goon = false
+  puts "Exiting"
+end
 
-request = nil
-options = {}
+def help socket = nil
+  puts "Valid commands are :"
+  $commands.keys.sort.each do |c|
+    puts "#{c} : #{Minep::Request::CommandsInfo[c]}"
+  end
+end
 
 optparse = OptionParser.new do |opts|
+  portSpecified = false
   opts.banner = <<-eos
-Usage: mine-request -r REQUEST [OPTION]... REQUEST_ARGUMENTS
+Usage: mine-request [OPTIONS]
 Send a request to a MINE server
-
-Valid requests are :
-#{MINEP.requestList}
 eos
 
-  opts.on("-r", "--request REQUEST",
-          MINEP.requestList, "request to send") do |r|
-    request = r
-  end
-
   opts.on "-h", "--host HOST", "server hostname" do |h|
-    options[:host] = h
+    $options[:host] = h
   end
 
   opts.on "-p", "--port PORT", Integer, "server port" do |p|
-    options[:port] = p
+    $options[:port] = p
+    portSpecified = true
+  end
+
+  opts.on "-t", "--type TYPE", [:tcp, :websocket], "type of communication (tcp | websocket)" do |t|
+    $options[:type] = t
+    $options[:port] = 8081 unless portSpecified
   end
 
   opts.on "--help", "displays this screen" do |h|
@@ -37,25 +70,33 @@ end
 
 begin
   optparse.parse!
-  if request.nil?
-    puts "Missing option : request\n"
-    puts optparse
-    exit 1
-  end
 rescue OptionParser::InvalidOption, OptionParser::MissingArgument, OptionParser::InvalidArgument
   puts $!.to_s
   puts optparse
   exit 1
-end  
-
-ARGV.each do |arg|
-  args = arg.split '='
-  options[args[0].to_sym] = args[1]
 end
-options[:closeLoop] = true
+
 begin
-  MINEP.send request, options
-rescue MINEP::ArgumentsError => e
-  $stderr.puts "Error : #{e}"
+  if $options[:type] == :tcp
+    socket = TCPSocket.new $options[:host], $options[:port]
+  elsif $options[:type] == :websocket
+    socket = WEBSocket::Socket.new $options[:host], $options[:port]
+  end
+rescue => e
+  $stderr.puts "Error : #{e} <#{$options[:host]} - #{$options[:port]}>"
   exit 1
 end
+
+while $goon do
+  printf ">> "
+  begin
+    cmd = Minep.read
+    if $commands.key? cmd
+      $commands[cmd].call socket
+    else
+      $stderr.puts "Error : unknown command"
+    end
+  rescue EOFError
+    quit
+  end
+end

data/lib/minep-request.rb

@@ -1 +1,5 @@
-require 'minep'
+require 'json'
+
+require "minep-request/version"
+require "minep-request/minep"
+require "minep-request/requests"

data/lib/minep-request/minep.rb

@@ -0,0 +1,26 @@
+module Minep
+  def self.read
+    input = $stdin.readline
+    input = input.strip
+  end
+
+  def self.makeMsg request, args
+    args.each_key do |k|
+      if k == :args
+        printf "#{k} as a space-separated list : "
+        input = read
+        args[k] = input.split
+      elsif k == :direction
+        printf "#{k} (up, right, down, left, origin, end) : "
+        args[k] = read
+      elsif k == :number
+        printf "#{k} : "
+        args[k] = read.to_i
+      else
+        printf "#{k} : "
+        args[k] = read
+      end
+    end
+    "#{request.upcase}=#{JSON.dump args}"
+  end
+end

data/lib/minep-request/requests.rb

@@ -0,0 +1,102 @@
+module Minep
+  module Request
+    CommandsInfo ||= {
+      "authenticate" => "Send an AUTHENTICATE request",
+      "signup" => "Send a SIGNUP request",
+      "exec" => "Send an EXEC request",
+      "insert" =>"Send an INSERT request",
+      "move" => "Send a MOVE request",
+      "backspace" => "Send a BACKSPACE request",
+      "delete" => "Send a DELETE request",
+      "file" => "Send a FILE request",
+      "help" => "Show the list of the commands",
+      "exit" => "Disconnect and quit the program",
+      "quit" => "Disconnect and quit the program"
+    }
+
+    def self.CommandsInfo
+      CommandsInfo
+    end
+
+    def self.file socket
+      args = {
+        :path => "",
+        :size => 0,
+        :line => 0,
+        :port => 0
+      }
+      printf "path : "
+      args[:path] = read
+      printf "line number : "
+      args[:line] = read.to_i
+      if File.exist? args[:path]
+        f = File.new args[:path]
+        args[:size] = f.size
+        args[:content] = f.read
+        socket.write "FILE=#{JSON.dump args}"
+      else
+        $stderr.puts "File #{args[:path]} doesn't exists"
+      end
+    end
+
+    def self.authenticate socket
+      args = {
+        :name => "",
+        :pass => ""
+      }
+      socket.write Minep.makeMsg("AUTHENTICATE", args)
+    end
+
+    def self.signup socket
+      args = {
+        :name => "",
+        :pass => "",
+        :email => "",
+        :website => ""
+      }
+      socket.write Minep.makeMsg("SIGNUP", args)
+    end
+
+    def self.exec socket
+      args = {
+        :buffer => "",
+        :command => "",
+        :args => []
+      }
+      socket.write Minep.makeMsg("EXEC", args)
+    end
+
+    def self.insert socket
+      args = {
+        :buffer => "",
+        :text => ""
+      }
+      socket.write Minep.makeMsg("INSERT", args)
+    end
+
+    def self.move socket
+      args = {
+        :buffer => "",
+        :direction => "",
+        :number => 0
+      }
+      socket.write Minep.makeMsg("MOVE", args)
+    end
+
+    def self.backspace socket
+      args = {
+        :buffer => "",
+        :number => 0
+      }
+      socket.write Minep.makeMsg("BACKSPACE", args)
+    end
+
+    def self.delete socket
+      args = {
+        :buffer => "",
+        :number => 0
+      }
+      socket.write Minep.makeMsg("DELETE", args)
+    end
+  end
+end

data/lib/minep-request/version.rb

@@ -0,0 +1,6 @@
+module Minep
+  module Request
+    VERSION = "0.0.4"
+    DATE = Time.now.to_s.split[0]
+  end
+end

data/minep-request.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'minep-request/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "minep-request"
+  gem.version       = Minep::Request::VERSION
+  gem.date          = Minep::Request::DATE
+  gem.authors       = ["Matthieu \"Ezveus\" Ciappara"]
+  gem.email         = ["ciappam@gmail.com"]
+  gem.description   = <<-EOS
+Binary allowing the communication with a MINE server. It support both MINE Protocol over TCP and over WebSocket.
+EOS
+  gem.summary       = %q{Binary allowing the communication with a MINE server}
+  gem.homepage      = "https://github.com/Ezveus/minep-request"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_runtime_dependency 'WEBSocket', '~> 0.0.1', '>= 0.0.1'
+end

metadata

@@ -1,37 +1,60 @@
 --- !ruby/object:Gem::Specification
 name: minep-request
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
-- Matthieu Ciappara
+- Matthieu "Ezveus" Ciappara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-19 00:00:00.000000000 Z
-dependencies: []
-description: ! 'Allows to communicate with a MINE server.
-
-  Supported requests are the same as the implemented requests in the server : AUTHENTICATE
-  and SIGNUP.
+date: 2013-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: WEBSocket
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+description: ! 'Binary allowing the communication with a MINE server. It support both
+  MINE Protocol over TCP and over WebSocket.
 
 '
-email: ciappam@gmail.com
+email:
+- ciappam@gmail.com
 executables:
 - mine-request
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/minep.rb
-- lib/minep-request.rb
-- lib/minep/connection.rb
-- lib/minep/exceptions.rb
-- lib/minep/minep.rb
-- lib/minep/request.rb
-- lib/minep/utils.rb
+- .gitignore
+- Gemfile
+- LICENSE.txt
 - README.md
+- Rakefile
 - bin/mine-request
+- lib/minep-request.rb
+- lib/minep-request/minep.rb
+- lib/minep-request/requests.rb
+- lib/minep-request/version.rb
+- minep-request.gemspec
 homepage: https://github.com/Ezveus/minep-request
 licenses: []
 post_install_message: 
@@ -55,6 +78,6 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Allows to communicate with a MINE server
+summary: Binary allowing the communication with a MINE server
 test_files: []
 has_rdoc: 

data/lib/minep.rb

@@ -1,8 +0,0 @@
-# Requiring external gems
-require 'eventmachine'
-require 'json'
-
-# Requiring internal files
-%w[minep request utils connection exceptions].each do |file|
-  require "minep/#{file}"
-end

data/lib/minep/connection.rb

@@ -1,44 +0,0 @@
-module MINEP
-  # This class extends EM::Connection (the connection class of EventMachine)
-  class Connection < EM::Connection
-    # Initialize the object
-    #
-    # @param [Hash] request is the request, The text request is built from this
-    def initialize request, closeLoop=false
-      super
-      @request = ["#{request[:header][:head]}\n"]
-      @closeLoop = closeLoop
-      request[:header].each do |key, value|
-        if key == :head
-          next
-        elsif key == :contentType
-          @request << "Content-Type: #{value}\n"
-        elsif key == :contentLength
-          @request << "Content-Length: #{value}\n"
-        else
-          @request << "#{key.to_s.capitalize}: #{value}\n"
-        end
-      end
-      @request << "\n"
-      key = request[:body].keys[0]
-      rqst = "#{key.to_s.upcase}="
-      rqst += "#{JSON.dump request[:body][key]}\n"
-      @request << rqst
-      @request = @request.join
-    end
-
-    # Send the request after the connection initialization
-    def post_init
-      send_data @request
-    end
-
-    # Receive the answer of the server and puts it on standard output
-    def receive_data data
-      puts data
-    end
-
-    def unbind
-      EventMachine::stop_event_loop if @closeLoop
-    end
-  end
-end

data/lib/minep/exceptions.rb

@@ -1,18 +0,0 @@
-module MINEP
-  class ArgumentsError < Exception
-  end
-
-  # Raise a ArgumentsError with "Not enough arguments for request" as an argument
-  #
-  # @param [String] rqst the request which called the function
-  def self.notEnoughArgs rqst
-    raise ArgumentsError, "Not enough arguments for request #{rqst}"
-  end
-
-  # Raise a ArgumentsError with "Missing mandatory arguments for request" as an argument
-  #
-  # @param [String] rqst the request which called the function
-  def self.missingArgs rqst
-    raise ArgumentsError, "Missing mandatory arguments for request #{rqst}"
-  end
-end

data/lib/minep/minep.rb

@@ -1,17 +0,0 @@
-module MINEP
-  # Send a request to opts\[:host\] or localhost on port
-  # opts\[:port\] or 8080
-  #
-  # @param [Symbol] type the request type, see main page for the requests list
-  # @param [Hash] opts stores the parameters of the request and host and port, see main page for the requests parameters
-  # @param [Bool] closeLoop define if the event loop has to be closed when unbinding
-  def self.send type, opts={}
-    request = {}
-    return false unless Utils.makeRequest request, type, opts
-    EM.run do
-      EM.connect(opts[:host] || "localhost",
-                 opts[:port] || 8080, Connection, request,
-                 opts[:closeLoop])
-    end
-  end
-end

data/lib/minep/request.rb

@@ -1,108 +0,0 @@
-module MINEP
-  RequestList = [
-                 :authenticate,
-                 :signup,
-                 :exec,
-                 :insert,
-                 :move,
-                 :backspace,
-                 :delete
-                ]
-
-  # Returns an array containing the request list
-  def self.requestList
-    RequestList
-  end
-
-  # Returns a string containing the request list under the form "\t-> request\n..."
-  def RequestList.to_s
-    "\t-> authenticate\n\t-> signup\n\t-> exec\n\t-> insert\n\t-> move\n\t-> backspace\n\t-> delete\n"
-  end
-
-  # Module containing methods for checking requests arguments
-  module Request
-
-    # Checks arguments for authenticate and create the request body
-    #
-    # @param [Hash] request will contain the request (headers and body)
-    # @param [Hash] opts contains the options and arguments get from MINEP.send
-    # @option opts [String] :name The user login/email
-    # @option opts [String] :pass The user password
-    def self.authenticate request, opts={}
-      MINEP.notEnoughArgs "AUTHENTICATE" if opts.empty?
-      MINEP.missingArgs "AUTHENTICATE" if opts[:name].nil? or opts[:pass].nil?
-      Utils.makeAuthenticate request, opts
-    end
-
-    # Checks arguments for signup and create the request body
-    # @param [String] website is the url of the website of the new user, passed through opts
-    #
-    # @param [Hash] request will contain the request (headers and body)
-    # @param [Hash] opts contains the options and arguments get from MINEP.send
-    # @option opts [String] :name The login of the new user
-    # @option opts [String] :pass The password of the new user
-    # @option opts [String] :email The email of the new user
-    def self.signup request, opts={}
-      MINEP.notEnoughArgs "SIGNUP" if opts.empty?
-      MINEP.missingArgs "SIGNUP" if opts[:name].nil? or opts[:pass].nil? or opts[:email].nil?
-      Utils.makeSignup request, opts
-    end
-
-    # Checks arguments for exec and create the request body
-    #
-    # @param [Hash] request will contain the request (headers and body)
-    # @param [Hash] opts contains the options and arguments get from MINEP.send
-    # @option opts [String] :buffer The buffer on which you apply the command
-    # @option opts [String] :command The command to apply
-    # @option opts [Array] :args The (potentially empty) array containing arguments for the command
-    def self.exec request, opts={}
-      MINEP.notEnoughArgs "EXEC" if opts.empty?
-      MINEP.missingArgs "SIGNUP" if opts[:buffer].nil? or opts[:command].nil? or opts[:args].nil?
-    end
-
-    # Checks arguments for insert and create the request body
-    #
-    # @param [Hash] request will contain the request (headers and body)
-    # @param [Hash] opts contains the options and arguments get from MINEP.send
-    # @option opts [String] :buffer The buffer on which you insert text
-    # @option opts [String] :text The text to insert
-    def self.insert request, opts={}
-      MINEP.notEnoughArgs "INSERT" if opts.empty?
-      MINEP.missingArgs "INSERT" if opts[:buffer].nil? or opts[:text].nil?
-    end
-
-    # Checks arguments for move and create the request body
-    #
-    # @param [Hash] request will contain the request (headers and body)
-    # @param [Hash] opts contains the options and arguments get from MINEP.send
-    # @option opts [String] :buffer The buffer on which you move the cursor
-    # @option opts [Symbol] :direction The direction of the move
-    # @option opts [Integer] :number The range of the move (unused on :origin or :end move)
-    def self.move request, opts={}
-      MINEP.notEnoughArgs "MOVE" if opts.empty?
-      MINEP.missingArgs "MOVE" if opts[:buffer].nil? or opts[:direction].nil? or opts[:number].nil?
-    end
-
-    # Checks arguments for backspace and create the request body
-    #
-    # @param [Hash] request will contain the request (headers and body)
-    # @param [Hash] opts contains the options and arguments get from MINEP.send
-    # @option opts [String] :buffer The buffer on which you suppress
-    # @option opts [Integer] :number The range of the suppression
-    def self.backspace request, opts={}
-      MINEP.notEnoughArgs "BACKSPACE" if opts.empty?
-      MINEP.missingArgs "BACKSPACE" if opts[:buffer].nil? or opts[:number].nil?
-    end
-
-    # Checks arguments for delete and create the request body
-    #
-    # @param [Hash] request will contain the request (headers and body)
-    # @param [Hash] opts contains the options and arguments get from MINEP.send
-    # @option opts [String] :buffer The buffer on which you delete
-    # @option opts [Integer] :number The range of the deletion
-    def self.delete request, opts={}
-      MINEP.notEnoughArgs "DELETE" if opts.empty?
-      MINEP.missingArgs "DELETE" if opts[:buffer].nil? or opts[:number].nil?
-    end
-  end
-end

data/lib/minep/utils.rb

@@ -1,70 +0,0 @@
-module MINEP
-  module Utils
-    # Make the request (header + body)
-    def self.makeRequest request, type, opts
-      Utils.getHeader request, opts[:host], opts[:port]
-      case type
-      when :authenticate then Request.authenticate request, opts
-      when :signup then Request.signup request, opts
-      when :exec then Request.exec request, opts
-      when :insert then Request.insert request, opts
-      when :move then Request.move request, opts
-      when :backspace then Request.backspace request, opts
-      when :delete then Request.delete request, opts
-      else
-        false
-      end
-    end
-
-    # Make the request header
-    def self.getHeader request, host=nil, port=nil
-      host = "localhost" if host.nil?
-      port = 8080 if host.nil?
-      request[:header] = {
-        :head => "POST /mine/protocol/request HTTP/1.1",
-        :host => "#{host}:#{port}",
-        :connection => "Keep-Alive",
-        :contentType => "application/x-www-form-urlencoded",
-        :contentLength => 0
-      }
-      true
-    end
-
-    # Calculate the body length
-    def self.calcLength request
-      rqst = request[:body].keys[0]
-      cL = rqst.size # rqst
-      cL += 3   # ={..}
-      request[:body][rqst].each do |key, value| # ..
-        cL += 6 + key.size + value.size # "key":"value",
-      end
-      cL -= 1   # the loop counts one inexistant ','
-    end
-
-    # Make the body for AUTHENTICATE request
-    def self.makeAuthenticate request, options
-      request[:body] = {
-        :authenticate => {
-          :name => options[:name],
-          :pass => options[:pass]
-        }
-      }
-      request[:header][:contentLength] = calcLength request
-      true
-    end
-
-    # Make the body for SIGNUP request
-    def self.makeSignup request, options
-      request[:body] = {
-        :signup => {
-          :name => options[:name],
-          :pass => options[:pass],
-          :email => options[:email],
-          :website => options[:website].to_s
-        }
-      }
-      request[:header][:contentLength] = calcLength request
-      true
-    end
-  end
-end