hobix 0.6

data/lib/hobix/util/patcher.rb

@@ -0,0 +1,155 @@
+#
+# = hobix/util/patcher
+#
+# Hobix command-line weblog system.
+#
+# Copyright (c) 2003-2004 why the lucky stiff
+#
+# Written & maintained by why the lucky stiff <why@ruby-lang.org>
+#
+# This program is free software, released under a BSD license.
+# See COPYING for details.
+#
+#--
+# $Id$
+#++
+require 'fileutils'
+
+module Hobix
+module Util
+# The Patcher class applies Hobix's own YAML patch format to a directory.
+# These patches can create or append to existing plain-text files, as well
+# as modifying YAML files using YPath.
+#
+# To apply your patch:
+#
+#   patch_set = Hobix::Util::Patcher['1.patch', '2.patch']
+#   patch_set.apply('/dir/to/unaltered/code')
+#
+class PatchError < Exception; end
+class Patcher
+    # Initialize the Patcher with a list of +paths+ to patches which
+    # must be applied in order.
+    #
+    #   patch_set = Hobix::Util::Patcher.new('1.patch', '2.patch')
+    #   patch_set.apply('/dir/to/unaltered/code')
+    #
+    def initialize( *paths )
+        @patches = {}
+        paths.each do |path|
+            YAML::load_file( path ).each do |k, v|
+                ( @patches[k] ||= [] ) << v
+            end
+        end
+    end
+
+    # Alias for Patcher.new.
+    #
+    #   patch_set = Hobix::Util::Patcher['1.patch', '2.patch']
+    #   patch_set.apply('/dir/to/unaltered/code')
+    #
+    def Patcher.[]( *paths )
+        Patcher.new( *paths )
+    end
+
+    # Apply the patches loaded into this class against a +path+ containing
+    # unaltered files.
+    #
+    #   patch_set = Hobix::Util::Patcher['1.patch', '2.patch']
+    #   patch_set.apply('/dir/to/unaltered/code')
+    #
+    def apply( path )
+        @patches.map do |fname, patchset|
+            fname = File.join( path, fname ) # .gsub( /^.*?[\/\\]/, '' ) )
+            ftarg = File.read( fname ) rescue ''
+            ftarg = YAML::load( ftarg ) if fname =~ /\.yaml$/
+            
+            patchset.each_with_index do |(ptype, patch), patchno|
+                # apply the changes
+                puts "*** Applying patch ##{ patchno + 1 } for #{ fname } (#{ ptype })."
+                ftarg = method( ptype.gsub( /\W/, '_' ) ).call( ftarg, patch )
+            end
+
+            [fname, ftarg]
+        end.
+        each do |fname, ftext|
+            # save the files
+            if ftext == :remove
+                FileUtils.rm_rf fname
+            else
+                FileUtils.makedirs( File.dirname( fname ) )
+                ftext = ftext.to_yaml if fname =~ /\.yaml$/
+                File.open( fname, 'w+' ) { |f| f << ftext }
+            end
+        end
+    end
+
+    def file_remove( target, text )
+        :remove
+    end
+
+    def file_create( target, text )
+        text.to_s
+    end
+
+    def file_ensure( target, text )
+        target << text unless target.include? text
+        target
+    end
+
+    def yaml_merge( obj, merge )
+        obj = obj.value if obj.respond_to? :value
+        if obj.class != merge.class and merge.class != Hash
+            raise PatchError, "*** Patch failure since #{ obj.class } != #{ merge.class }."
+        end
+
+        case obj
+        when Hash
+            merge.each do |k, v|
+                if obj.has_key? k
+                    yaml_merge obj[k], v
+                else
+                    obj[k] = v
+                end
+            end
+        when Array
+            at = nil
+            merge.each do |v|
+                vat = obj.index( v )
+                if vat
+                    at = vat if vat > at.to_i
+                else
+                    if at
+                        obj[at+=1,0] = v
+                    else
+                        obj << v
+                    end
+                end
+            end
+        when String
+            obj.replace merge
+        else
+            merge.each do |k, v|
+                ivar = obj.instance_variable_get "@#{k}"
+                if ivar
+                    yaml_merge ivar, v
+                else
+                    obj.instance_variable_set "@#{k}", v
+                end
+            end
+        end
+
+        obj
+    end
+end
+end
+end
+
+YAML::add_domain_type( 'hobix.com,2004', 'patches/list' ) do |type, val|
+    val
+end
+['yaml-merge', 'file-create', 'file-ensure', 'file-remove'].each do |ptype|
+    YAML::add_domain_type( 'hobix.com,2004', 'patches/' + ptype ) do |type, val|
+        [ptype, val]
+    end
+end

data/lib/hobix/webapp/cli.rb

@@ -0,0 +1,195 @@
+# = webapp command line interface
+#
+# A web application using webapp has CLI (command line interface).
+# You can invoke a webapp script from command line.
+#
+#   xxx.cgi [options] [/path_info] [?query_string]
+#       -h, --help                       show this message
+#       -o, --output=FILE                set output file
+#           --cern-meta                  output header as CERN httpd metafile
+#           --server-name=STRING         set server name
+#           --server-port=INTEGER        set server port number
+#           --script-name=STRING         set script name
+#           --remote-addr=STRING         set remote IP address
+#           --header=NAME:BODY           set additional request header
+#
+# For example, hello.cgi, as follows, can be invoked from command line.
+#
+#   % cat hello.cgi 
+#   #!/usr/bin/env ruby
+#   require 'webapp'
+#   WebApp {|w| w.puts "Hello" }
+#   % ./hello.cgi 
+#   Status: 200 OK
+#   Content-Type: text/plain
+#   Content-Length: 6
+#  
+#   Hello
+#
+# webapp.rb can be used in command line directly as follows.
+# This document use the form to make examples short. 
+#
+#   % ruby -rwebapp -e 'WebApp {|w| w.puts "Hello" }'
+#   Status: 200 OK
+#   Content-Type: text/plain
+#   Content-Length: 6
+#  
+#   Hello
+#
+# The web application takes two optional argument: path info and query string.
+# The optional first argument which begins with '/' is path info.
+# The optional second argument which begins with '?' is query string.
+# Since '?' is a shell meta character, it should be quoted.
+#
+#   % ruby -rwebapp -e '
+#     WebApp {|w|
+#       w.puts w.path_info
+#       w.puts w.query_string
+#     }' /a '?q'
+#   Status: 200 OK
+#   Content-Type: text/plain
+#   Content-Length: 30
+#  
+#   /a
+#   #<WebApp::QueryString: ?q>
+#
+# If the option -o is specified, a response is generated on the specified file.
+# Note that the format is suitable for Apache mod_asis.
+#
+#   % ruby -rwebapp -e 'WebApp {|w| w.puts "Hello" }' -- -o ~/public_html/hello.asis
+#   % cat ~/public_html/hello.asis 
+#   Status: 200 OK
+#   Content-Type: text/plain
+#   Content-Length: 6
+#
+#   Hello
+# 
+# If the option --cern-meta is specified addition to -o,
+# The header in the response is stored in separated file.
+# Note that the format is suitable for Apache mod_cern_meta.
+#
+#   % ruby -rwebapp -e 'WebApp {|w| w.puts "Hello" }' -- --cern-meta -o ~/public_html/hello2.txt
+#   % cat ~/public_html/.web/hello2.txt.meta 
+#   Content-Type: text/plain
+#   Content-Length: 6
+#   % cat ~/public_html/hello2.txt 
+#   Hello
+#
+# The options --server-name, --server-port, --script-name and --remote-addr specifies  
+# information visible from web application.
+# For example, WebApp#server_name returns a server name specified by --server-name.
+#
+#   % ruby -rwebapp -e 'WebApp {|w| w.puts w.server_name }'
+#   Status: 200 OK
+#   Content-Type: text/plain
+#   Content-Length: 10
+#  
+#   localhost
+#   % ruby -rwebapp -e 'WebApp {|w| w.puts w.server_name }' -- --server-name=www.example.org
+#   Status: 200 OK
+#   Content-Type: text/plain
+#   Content-Length: 16
+#
+#   www.example.org
+#
+# The option --header specifies an additional request header.
+# For example, specifying "Accept-Encoding: gzip" makes output gzipped.
+#
+#   % ruby -rwebapp -e 'WebApp {|w| w.puts "Hello"*100 }' -- --header='Accept-Encoding: gzip'|cat -v 
+#   Status: 200 OK
+#   Content-Type: text/plain
+#   Content-Encoding: gzip
+#   Content-Length: 31
+#
+#   ^_M-^K^H^@^O^VM-TA^@^CM-sHM-MM-IM-IM-w^X%F^RM-A^E^@ZTsDM-u^A^@^@
+
+require 'optparse'
+
+module Hobix
+class WebApp
+  class Manager
+    # CLI (command line interface)
+    def run_cli
+      opt_output = '-'
+      opt_cern_meta = false
+      opt_server_name = 'localhost'
+      opt_server_port = 80
+      opt_script_name = "/#{File.basename($0)}"
+      opt_remote_addr = '127.0.0.1'
+      opt_headers = []
+      ARGV.options {|q|
+        q.banner = "#{File.basename $0} [options] [/path_info] [?query_string]"
+        q.def_option('-h', '--help', 'show this message') { puts q; exit(0) }
+        q.def_option('-o FILE', '--output=FILE', 'set output file') {|arg| opt_output = arg.untaint }
+        q.def_option('--cern-meta', 'output header as CERN httpd metafile') { opt_cern_meta = true }
+        q.def_option('--server-name=STRING', 'set server name') {|arg| opt_server_name = arg }
+        q.def_option('--server-port=INTEGER', 'set server port number') {|arg| opt_server_port = arg.to_i }
+        q.def_option('--script-name=STRING', 'set script name') {|arg| opt_script_name = arg }
+        q.def_option('--remote-addr=STRING', 'set remote IP address') {|arg| opt_remote_addr = arg }
+        q.def_option('--header=NAME:BODY', 'set additional request header') {|arg| opt_headers << arg.split(/:/, 2) }
+        q.parse!
+      }
+      if path_info = ARGV.shift
+        if %r{\A/} !~ path_info
+          ARGV.unshift path_info
+          path_info = nil
+        end
+      end
+      if query_string = ARGV.shift
+        if %r{\A\?} !~ query_string
+          ARGV.unshift query_string
+          query_string = nil
+        end
+      end
+      if !ARGV.empty?
+        raise "extra arguments: #{ARGV.inspect[1..-2]}"
+      end
+      path_info ||= ''
+      query_string ||= ''
+      setup_request = lambda {|req|
+        req.make_request_header_from_cgi_env({
+          'REQUEST_METHOD' => 'GET',
+          'SERVER_NAME' => opt_server_name,
+          'SERVER_PORT' => opt_server_port,
+          'SCRIPT_NAME' => opt_script_name,
+          'PATH_INFO' => path_info,
+          'QUERY_STRING' => query_string,
+          'SERVER_PROTOCOL' => 'HTTP/1.0',
+          'REMOTE_ADDR' => opt_remote_addr,
+          'CONTENT_TYPE' => ''
+        })
+        opt_headers.each {|name, body|
+          req.header_object.add name, body
+        }
+      }
+      output_response = lambda {|res|
+        if opt_output == '-'
+          res.output_cgi_status_field($stdout)
+          res.output_message($stdout)
+        else
+          if opt_cern_meta
+            dir = "#{File.dirname(opt_output)}/.web"
+            begin
+              Dir.mkdir dir
+            rescue Errno::EEXIST
+            end
+            open("#{dir}/#{File.basename(opt_output)}.meta", 'w') {|f|
+              #res.output_cgi_status_field(f)
+              res.output_header(f)
+            }
+            open(opt_output, 'w') {|f|
+              res.output_body(f)
+            }
+          else
+            open(opt_output, 'w') {|f|
+              res.output_cgi_status_field(f)
+              res.output_message(f)
+            }
+          end
+        end
+      }
+      primitive_run(setup_request, output_response)
+    end
+  end
+end
+end

data/lib/hobix/webapp/htmlform.rb

@@ -0,0 +1,107 @@
+module Hobix
+class WebApp
+  class QueryString
+    # decode self as application/x-www-form-urlencoded and returns
+    # HTMLFormQuery object.
+    def decode_as_application_x_www_form_urlencoded
+      # xxx: warning if invalid?
+      pairs = []
+      @escaped_query_string.scan(/([^&;=]*)=([^&;]*)/) {|key, val|
+        key.gsub!(/\+/, ' ')
+        key.gsub!(/%([0-9A-F][0-9A-F])/i) { [$1].pack("H*") }
+        val.gsub!(/\+/, ' ')
+        val.gsub!(/%([0-9A-F][0-9A-F])/i) { [$1].pack("H*") }
+        pairs << [key.freeze, val.freeze]
+      }
+      HTMLFormQuery.new(pairs)
+    end
+    # decode self as multipart/form-data and returns
+    # HTMLFormQuery object.
+    def decode_as_multipart_form_data( boundary )
+      # xxx: warning if invalid?
+      require 'tempfile'
+      pairs = []
+      boundary = "--" + boundary
+      eol = "\015\012"
+      str = @escaped_query_string.gsub( /(?:\r?\n|\A)#{ Regexp::quote( boundary ) }--#{ eol }.*/m, '' )
+      str.split( /(?:\r?\n|\A)#{ Regexp::quote( boundary ) }#{ eol }/m ).each do |part|
+          headers = {}
+          header, value = part.split( "#{eol}#{eol}", 2 )
+          next unless header and value
+          field_name, field_data = nil, {}
+          if header =~ /Content-Disposition: form-data;.*(?:\sname="([^"]+)")/m
+              field_name = $1
+          end
+          if header =~ /Content-Disposition: form-data;.*(?:\sfilename="([^"]+)")/m
+              body = Tempfile.new( "WebApp" )
+              body.binmode if defined? body.binmode
+              body.print value
+              body.rewind
+              field_data = {'filename' => $1, 'tempfile' => body}
+              field_data['type'] = $1 if header =~ /Content-Type: (.+?)(?:#{ eol }|\Z)/m
+          else
+              field_data = value.gsub( /#{ eol }\Z/, '' )
+          end
+          pairs << [field_name, field_data]
+      end
+      HTMLFormQuery.new(pairs)
+    end
+  end
+
+  # HTMLFormQuery represents a query submitted by HTML form. 
+  class HTMLFormQuery
+
+    def HTMLFormQuery.each_string_key_pair(arg, &block) # :nodoc:
+      if arg.respond_to? :to_ary
+        arg = arg.to_ary
+        if arg.length == 2 && arg.first.respond_to?(:to_str)
+          yield WebApp.make_frozen_string(arg.first), arg.last
+        else
+          arg.each {|elt|
+            HTMLFormQuery.each_string_key_pair(elt, &block)
+          }
+        end
+      elsif arg.respond_to? :to_pair
+        arg.each_pair {|key, val|
+          yield WebApp.make_frozen_string(key), val
+        }
+      else
+        raise ArgumentError, "non-pairs argument: #{arg.inspect}"
+      end
+    end
+
+    def initialize(*args)
+      @param = []
+      HTMLFormQuery.each_string_key_pair(args) {|key, val|
+        @param << [key, val]
+      }
+      @param.freeze
+    end
+
+    def each
+      @param.each {|key, val|
+        yield key.dup, val.dup
+      }
+    end
+
+    def [](key)
+      if pair = @param.assoc(key)
+        return pair.last.dup
+      end
+      return nil
+    end
+
+    def lookup_all(key)
+      result = []
+      @param.each {|k, val|
+        result << val if k == key
+      }
+      return result
+    end
+
+    def keys
+      @param.map {|key, val| key }.uniq
+    end
+  end
+end
+end

data/lib/hobix/webapp/message.rb

@@ -0,0 +1,177 @@
+module Hobix
+class WebApp
+  # :stopdoc:
+  class Header
+    def Header.capitalize_field_name(field_name)
+      field_name.gsub(/[A-Za-z]+/) {|s| s.capitalize }
+    end
+
+    def initialize
+      @fields = []
+    end
+
+    def freeze
+      @fields.freeze
+      super
+    end
+
+    def dup
+      result = Header.new
+      @fields.each {|_, k, v|
+        result.add(k, v)
+      }
+      result
+    end
+
+    def clear
+      @fields.clear
+    end
+
+    def remove(field_name)
+      k1 = field_name.downcase
+      @fields.reject! {|k2, _, _| k1 == k2 }
+      nil
+    end
+
+    def add(field_name, field_body)
+      field_name = WebApp.make_frozen_string(field_name)
+      field_body = WebApp.make_frozen_string(field_body)
+      @fields << [field_name.downcase.freeze, field_name, field_body]
+    end
+
+    def set(field_name, field_body)
+      field_name = WebApp.make_frozen_string(field_name)
+      remove(field_name)
+      add(field_name, field_body)
+    end
+
+    def has?(field_name)
+      @fields.assoc(field_name.downcase) != nil
+    end
+
+    def [](field_name)
+      k1 = field_name.downcase
+      @fields.each {|k2, field_name, field_body|
+        return field_body.dup if k1 == k2
+      }
+      nil
+    end
+
+    def lookup_all(field_name)
+      k1 = field_name.downcase
+      result = []
+      @fields.each {|k2, field_name, field_body|
+        result << field_body.dup if k1 == k2
+      }
+      result
+    end
+
+    def each
+      @fields.each {|_, field_name, field_body|
+        field_name = field_name.dup
+        field_body = field_body.dup
+        yield field_name, field_body
+      }
+    end
+  end
+
+  class Message
+    def initialize(header={}, body='')
+      @header_object = Header.new
+      case header
+      when Hash
+        header.each_pair {|k, v|
+          raise ArgumentError, "unexpected header field name: #{k.inspect}" unless k.respond_to? :to_str
+          raise ArgumentError, "unexpected header field body: #{v.inspect}" unless v.respond_to? :to_str
+          @header_object.add k.to_str, v.to_str
+        }
+      when Array
+        header.each {|k, v|
+          raise ArgumentError, "unexpected header field name: #{k.inspect}" unless k.respond_to? :to_str
+          raise ArgumentError, "unexpected header field body: #{v.inspect}" unless v.respond_to? :to_str
+          @header_object.add k.to_str, v.to_str
+        }
+      else
+        raise ArgumentError, "unexpected header argument: #{header.inspect}"
+      end
+      raise ArgumentError, "unexpected body: #{body.inspect}" unless body.respond_to? :to_str
+      @body_object = StringIO.new(body.to_str)
+    end
+    attr_reader :header_object, :body_object
+
+    def freeze
+      @header_object.freeze
+      @body_object.string.freeze
+      super
+    end
+
+    def output_header(out)
+      @header_object.each {|k, v|
+        out << "#{k}: #{v}\n"
+      }
+    end
+
+    def output_body(out)
+      out << @body_object.string
+    end
+
+    def output_message(out)
+      output_header(out)
+      out << "\n"
+      output_body(out)
+    end
+  end
+
+  class Request < Message
+    def initialize(request_line=nil, header={}, body='')
+      @request_line = request_line
+      super header, body
+    end
+    attr_reader :request_method,
+                :server_name, :server_port,
+                :script_name, :path_info,
+                :query_string,
+                :server_protocol,
+                :remote_addr, :content_type, :request_uri, :action_uri
+
+    def make_request_header_from_cgi_env(env)
+      env.each {|k, v|
+        next if /\AHTTP_/ !~ k
+        k = Header.capitalize_field_name($')
+        k.gsub!(/_/, '-')
+        @header_object.add k, v
+      }
+      @request_method = env['REQUEST_METHOD']
+      @server_name = ( env['SERVER_NAME'] || '' ).gsub( /\:\d+$/, '' )  # lighttpd affixes port!!
+      @server_port = env['SERVER_PORT'].to_i
+      @script_name = env['SCRIPT_NAME'] || ''
+      @path_info = env['PATH_INFO'] || ''
+      @query_string = QueryString.primitive_new_for_raw_query_string(env['QUERY_STRING'] || '')
+      @server_protocol = env['SERVER_PROTOCOL'] || ''
+      @remote_addr = env['REMOTE_ADDR'] || ''
+      @content_type = env['CONTENT_TYPE'] || ''
+
+      # non-standard:
+      @request_uri = env['REQUEST_URI'] # Apache
+
+      # hobix action uri
+      @action_uri = ( env['PATH_INFO'] || env['REQUEST_URI'] ).
+        gsub( /^(#{ Regexp::quote( File::dirname( @script_name ) ) })?\/*/, '' ).
+        gsub( /\?.+$/, '' )
+    end
+  end
+
+  class Response < Message
+    def initialize(status_line='200 OK', header={}, body='')
+      @status_line = status_line
+      super header, body
+    end
+    attr_accessor :status_line
+
+    def output_cgi_status_field(out)
+      out << "Status: #{self.status_line}\n"
+    end
+  end
+  # :startdoc:
+end
+end