wunderbar 0.8.14 → 0.9.0

data/README.md

@@ -12,9 +12,42 @@ Wunderbar is both inspired by, and builds upon Jim Weirich's
 [Builder](https://github.com/jimweirich/builder#readme), and provides 
 the element id and class id syntax and based on the implementation from
 [Markaby](http://markaby.rubyforge.org/).
-.
 
-Quick Start
+Wunderbar's JSON support is inspired by David Heinemeier Hansson's
+[jbuilder](https://github.com/rails/jbuilder).
+
+Overview
+---
+
+The premise of Wunderbar is that output of various types are typically formed
+by appending either a series of key/value pairs or simple values, and those
+operations should be optimized for.  Appending a key/value pair is done via:
+
+    _key value
+
+... and appending a simple value is done thus:
+
+    _ value
+
+For HTML, key/value is used for element nodes, and simple values are used for
+text nodes.  For JSON, key/value is used for Hashes and simple values are used
+for arrays.  For text, simple values are output via puts, and key/value pairs
+are not used.
+
+Nesting is performed using blocks.
+
+The underscore method, when passed no arguments, returns an object that can be
+used to perform a number of special functions.  Some of those functions are
+unique to the output method.  Others like logging methods are common.
+
+The underscore method when passed multiple arguments or a combination of
+arguments and a block may do other common functions, depending on the types of
+the arguments passed.
+
+Question mark, exclamation mark, and underscore suffixes to the method name
+may modify the results.
+
+Quick Start (HTML)
 ---
 
 Simple element:
@@ -112,14 +145,15 @@ output.  This is accomplished by providing one or more of the following:
     end
  
     Wunderbar.json do
-      expression
+      code
     end
 
     Wunderbar.text do
       code
     end
  
-Arbitrary Ruby code can be placed in each.  For html, use the `_` methods described here.  For json, the results (typically a hash or array) are converted to JSON.  For text, use `puts` and `print` statements to produce the desired results.
+Arbitrary Ruby code can be placed in each.  To append to the output produced,
+use the `_` methods described here.
 
 Methods provided to Wunderbar.html
 ---
@@ -154,6 +188,76 @@ Access to all of the builder _defined_ methods (typically these end in an esclam
 * `_.tag! :foo`
 * `_.error 'Log message'`
 
+XHTML differs from HTML in the escaping of inline style and script elements.
+XHTML will also fall back to HTML output unless the user agent indicates it
+supports XHTML via the HTTP Accept header.
+
+Methods provided to Wunderbar.json
+---
+
+Common operations are to return a Hash or an Array of values.  Hashes are
+a series of name/value pairs, and Arrays are a series of values.
+
+``` ruby
+Wunderbar.json do
+  _content format_content(@message.content)
+  _ @message, :created_at, :updated_at 
+
+  _author do
+    _name @message.creator.name.familiar
+    _email_address @message.creator.email_address_with_name
+    _url url_for(@message.creator, format: :json)
+  end
+
+  if current_user.admin?
+    _visitors calculate_visitors(@message)
+  end
+
+  _comments @message.comments, :content, :created_at
+  
+  _attachments @message.attachments do |attachment|
+    _filename attachment.filename
+    _url url_for(attachment)
+  end
+end
+```
+
+Invoking methods that start with a Unicode 
+[low line](http://www.fileformat.info/info/unicode/char/5f/index.htm) 
+character ("_") will add a key/value pair to that hash.  Hashes can
+also be nested.  Logic can be freely intermixed.
+
+The "`_`" method serves a number of purposes.
+
+* calling it with multiple arguments will cause the first argument to be
+treated as the object, and the remainder as the attributes to be extracted
+    * Example: `_ File.stat('foo'), :mtime, :size, :mode`
+
+* calling it with a single Enumerable object and a block will cause an array
+to be returned based on mapping each objection from the enumeration against
+the block
+   * Example: `_([1,2,3]) {|n| n*n}`
+
+* arrays can be also be built using the `_` method:
+        _ 1
+        _ 2
+
+The `_` method returns a proxy to the object being constructed.  This is often
+handy when called with no arguments.  Examples:
+
+        _.sort!
+        _['foo'] = 'bar'
+
+Methods provided to Wunderbar.text
+---
+
+Appending to the output stream is done using the `_` method, which is
+equivalent to `puts`.  The `_` method returns an object which proxies the
+output stream, which provides access to other useful methods, for example:
+
+        _.print 'foo'
+        _.printf "Hello %s!\n", 'world'
+
 Globals provided
 ---
 * `$cgi`   - Common Gateway Interface

data/lib/wunderbar/builder.rb

@@ -170,4 +170,130 @@ module Wunderbar
       $HTTP_POST
     end
   end
+
+  class TextBuilder
+    def initialize
+      require 'stringio'
+      @_target = StringIO.new
+    end
+
+    def encode(params = {}, &block)
+      params.each do |key,value|
+        instance_variable_set "@#{key}", value.first if key =~ /^\w+$/
+      end
+
+      self.instance_eval(&block)
+      @_target.string
+    end
+
+    def _(*args)
+      @_target.puts *args if args.length > 0 
+      self
+    end
+
+    # forward to either Wunderbar or @_target
+    def method_missing(method, *args, &block)
+      if Wunderbar.respond_to? method
+        return Wunderbar.send method, *args, &block
+      elsif @_target.respond_to? method
+        return @_target.send method, *args, &block
+      else
+        super
+      end
+    end
+
+    def target!
+      @_target.string
+    end
+  end
+
+  class JsonBuilder
+    def initialize
+      @_target = {}
+    end
+
+    def encode(params = {}, &block)
+      params.each do |key,value|
+        instance_variable_set "@#{key}", value.first if key =~ /^\w+$/
+      end
+
+      self.instance_eval(&block)
+      @_target
+    end
+
+    # forward to either Wunderbar or @_target
+    def method_missing(method, *args, &block)
+
+      if method.to_s =~ /^_(\w*)$/
+        name = $1
+      elsif Wunderbar.respond_to? method
+        return Wunderbar.send method, *args, &block
+      elsif @_target.respond_to? method
+        return @_target.send method, *args, &block
+      else
+        super
+      end
+
+      if args.length == 0
+        return self unless block
+        result = JsonBuilder.new.encode(&block)
+      elsif args.length == 1
+        result = args.first
+
+        if block
+          if Symbol === result or String === result
+            result = {result.to_s => JsonBuilder.new.encode(&block)}
+          else
+            result = result.map {|n| @_target = {}; block.call(n); @_target} 
+          end
+        end
+      elsif block
+        ::Kernel::raise ::ArgumentError, 
+          "can't mix multiple arguments with a block"
+      else
+        object = args.shift
+
+        if not Enumerable === object or String === object or Struct === object
+          result = {}
+          args.each {|arg| result[arg.to_s] = object.send arg}
+        else
+          result = object.map do |item|
+            args.inject({}) {|hash, arg| hash[arg.to_s] = item.send arg; hash}
+          end
+        end
+      end
+
+      if name != ''
+        unless Hash === @_target or @_target.empty?
+          ::Kernel::raise ::ArgumentError, "mixed array and hash calls"
+        end
+
+        @_target[name.to_s] = result
+      elsif args.length == 0 or (args.length == 1 and not block)
+        @_target = [] if @_target == {}
+
+        if Hash === @_target 
+          ::Kernel::raise ::ArgumentError, "mixed hash and array calls"
+        end
+
+        @_target << result
+      else
+        @_target = result
+      end
+
+      self
+    end
+
+    def _!(object)
+      @_target = object
+    end
+
+    def target!
+      begin
+        JSON.pretty_generate(@_target)+ "\n"
+      rescue
+        @_target.to_json + "\n"
+      end
+    end
+  end
 end

data/lib/wunderbar/cgi-methods.rb

@@ -4,44 +4,47 @@ module Wunderbar
 
     # produce json
     def self.json(&block)
-      $param.each do |key,value| 
-        instance_variable_set "@#{key}", value.first if key =~ /^\w+$/
-      end
-      output = instance_eval(&block)
+      builder = JsonBuilder.new
+      output = builder.encode($param, &block)
+      Kernel.print "Status: 404 Not Found\r\n" if output == {}
     rescue Exception => exception
       Kernel.print "Status: 500 Internal Error\r\n"
-      output = {
-        :exception => exception.inspect,
-        :backtrace => exception.backtrace
-      }
+      Wunderbar.error exception.inspect
+      backtrace = []
+      exception.backtrace.each do |frame| 
+        next if frame =~ %r{/wunderbar/}
+        next if frame =~ %r{/gems/.*/builder/}
+        Wunderbar.warn "  #{frame}"
+        backtrace << frame 
+      end
+      builder = JsonBuilder.new
+      builder._exception exception.inspect
+      builder._backtrace backtrace
     ensure
-      Kernel.print "Status: 404 Not Found\r\n" unless output
       out? 'type' => 'application/json', 'Cache-Control' => 'no-cache' do
-        begin
-          JSON.pretty_generate(output)+ "\n"
-        rescue
-          output.to_json + "\n"
-        end
+        builder.target!
       end
     end
 
     # produce text
     def self.text &block
-      require 'stringio'
-      buffer = StringIO.new
-      $param.each do |key,value| 
-        instance_variable_set "@#{key}", value.first if key =~ /^\w+$/
-      end
-      buffer.instance_eval &block
+      builder = TextBuilder.new
+      output = builder.encode($param, &block)
+      Kernel.print "Status: 404 Not Found\r\n" if output == ''
     rescue Exception => exception
+      Wunderbar.error exception.inspect
       Kernel.print "Status: 500 Internal Error\r\n"
-      buffer << "\n" unless buffer.size == 0
-      buffer << exception.inspect + "\n"
-      exception.backtrace.each {|frame| buffer << "  #{frame}\n"}
+      builder.puts unless builder.size == 0
+      builder.puts exception.inspect
+      exception.backtrace.each do |frame| 
+        next if frame =~ %r{/wunderbar/}
+        next if frame =~ %r{/gems/.*/builder/}
+        Wunderbar.warn "  #{frame}"
+        builder.puts "  #{frame}"
+      end
     ensure
-      Kernel.print "Status: 404 Not Found\r\n" if buffer.size == 0
       out? 'type' => 'text/plain', 'Cache-Control' => 'no-cache' do
-        buffer.string
+        builder.target!
       end
     end
 

data/lib/wunderbar/logger.rb

@@ -3,7 +3,7 @@ require 'logger'
 module Wunderbar
   def self.logger
     return @logger if @logger
-    @logger = Logger.new(STDERR)
+    @logger = Logger.new($stderr)
     @logger.level = Logger::WARN
     @logger.formatter = proc { |severity, datetime, progname, msg|
       "_#{severity} #{msg}\n"
@@ -11,6 +11,10 @@ module Wunderbar
     @logger
   end
 
+  def self.logger= new_logger
+    @logger = new_logger
+  end
+
   def self.log_level=(level)
     return unless level
 

data/lib/wunderbar/version.rb

@@ -1,8 +1,8 @@
 module Wunderbar
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 8
-    TINY  = 14
+    MINOR = 9
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/wunderbar.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = "wunderbar"
-  s.version = "0.8.14"
+  s.version = "0.9.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sam Ruby"]
-  s.date = "2012-03-30"
+  s.date = "2012-04-01"
   s.description = "    Wunderbar makes it easy to produce valid HTML5, wellformed XHTML, Unicode\n    (utf-8), consistently indented, readable applications.  This includes\n    output that conforms to the Polyglot specification and the emerging\n    results from the XML Error Recovery Community Group.\n"
   s.email = "rubys@intertwingly.net"
   s.files = ["wunderbar.gemspec", "README.md", "COPYING", "lib/wunderbar.rb", "lib/wunderbar", "lib/wunderbar/installation.rb", "lib/wunderbar/html-methods.rb", "lib/wunderbar/job-control.rb", "lib/wunderbar/logger.rb", "lib/wunderbar/builder.rb", "lib/wunderbar/environment.rb", "lib/wunderbar/cgi-methods.rb", "lib/wunderbar/cssproxy.rb", "lib/wunderbar/version.rb"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: wunderbar
 version: !ruby/object:Gem::Version 
-  hash: 35
+  hash: 59
   prerelease: 
   segments: 
   - 0
-  - 8
-  - 14
-  version: 0.8.14
+  - 9
+  - 0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Sam Ruby
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-30 00:00:00 Z
+date: 2012-04-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: builder