mullen-wee 2.2.0

data/lib/wee/html_canvas.rb

@@ -0,0 +1,254 @@
+require 'wee/renderer'
+
+module Wee
+
+  class HtmlCanvas < Renderer
+
+    def initialize(*args)
+      super
+      @current_brush = nil
+    end
+
+    def close
+      @current_brush.close if @current_brush
+      @current_brush = nil
+    end
+
+    def nest
+      old_brush = @current_brush
+      # we don't want that Brush#close is calledas #nest
+      # is called from #with -> this avoids an infinite loop
+      @current_brush = nil 
+      yield
+      @current_brush.close if @current_brush
+      @current_brush = old_brush
+    end
+
+    def self.brush_tag(attr, klass, *args_to_new)
+      args_to_new = args_to_new.map {|a| a.inspect}.join(", ")
+      if klass.instance_method(:with).arity != 0
+        class_eval %{ 
+          def #{attr}(*args, &block)
+            handle(#{klass}.new(#{args_to_new}), *args, &block)
+          end
+        }
+      elsif klass.nesting?
+        class_eval %{ 
+          def #{attr}(&block)
+            handle2(#{klass}.new(#{args_to_new}), &block)
+          end
+        }
+      else
+        class_eval %{ 
+          def #{attr}
+            handle3(#{klass}.new(#{args_to_new}))
+          end
+        }
+      end
+    end 
+
+    def self.generic_tag(*attrs)
+      attrs.each {|attr| brush_tag attr, Brush::GenericTagBrush, attr }
+    end
+
+    def self.generic_single_tag(*attrs)
+      attrs.each {|attr| brush_tag attr, Brush::GenericSingleTagBrush, attr }
+    end
+
+    generic_tag :html, :head, :body, :title, :label
+    generic_tag :h1, :h2, :h3, :h4, :h5
+    generic_tag :div, :span, :ul, :ol, :li, :pre
+    generic_single_tag :hr
+
+    brush_tag :link, Brush::LinkTag
+    brush_tag :table, Brush::TableTag
+    brush_tag :table_row, Brush::TableRowTag
+    brush_tag :table_data, Brush::TableDataTag
+    brush_tag :table_header, Brush::TableHeaderTag
+    brush_tag :form, Brush::FormTag
+    brush_tag :input, Brush::InputTag
+    brush_tag :hidden_input, Brush::HiddenInputTag
+    brush_tag :password_input, Brush::PasswordInputTag
+    brush_tag :text_input, Brush::TextInputTag
+    brush_tag :radio_button, Brush::RadioButtonTag
+    brush_tag :check_box, Brush::CheckboxTag; alias checkbox check_box
+    brush_tag :text_area, Brush::TextAreaTag
+    brush_tag :option, Brush::SelectOptionTag
+    brush_tag :submit_button, Brush::SubmitButtonTag
+    brush_tag :image_button, Brush::ImageButtonTag
+    brush_tag :file_upload, Brush::FileUploadTag
+    brush_tag :page, Brush::Page
+    brush_tag :anchor, Brush::AnchorTag
+    brush_tag :javascript, Brush::JavascriptTag
+    brush_tag :image, Brush::ImageTag
+    brush_tag :style, Brush::StyleTag
+
+    brush_tag :bold, Brush::GenericTagBrush, :b
+    brush_tag :paragraph, Brush::GenericTagBrush, :p
+    brush_tag :break, Brush::GenericSingleTagBrush, :br
+
+    def select_list(items, &block)
+      handle2(Brush::SelectListTag.new(items), &block)
+    end
+
+    HTML_NBSP = "&nbsp;".freeze
+
+    def space(n=1)
+      text(HTML_NBSP*n)
+    end
+
+    def text(str)
+      @current_brush.close if @current_brush
+      @current_brush = nil
+      @document.text(str)
+      nil
+    end
+
+    alias << text
+
+    def encode_text(str)
+      @current_brush.close if @current_brush
+      @current_brush = nil
+      @document.encode_text(str)
+      nil
+    end
+
+    def css(str)
+      style.type('text/css').with(str)
+    end
+
+    #
+    # Depends on an existing divert location :styles.
+    #
+    def render_style(component)
+      once(component.class) { try_divert(:styles, component.style) }
+    end
+
+    #
+    # converts \n into <br/>
+    #
+    def multiline_text(str, encode=true)
+      @current_brush.close if @current_brush
+      @current_brush = nil
+
+      first = true
+      str.each_line do |line|
+        @document.single_tag(:br) unless first
+        first = false
+
+        if encode
+          @document.encode_text(line)
+        else
+          @document.text(line)
+        end
+      end 
+    end
+
+    #
+    # Define a divert location
+    #
+    def define_divert(tag)
+      @document.define_divert(tag)
+    end
+
+    #
+    # Change into an existing divert location and 
+    # append +txt+ or the contents of +block+.
+    #
+    def divert(tag, txt=nil, &block)
+      @document.divert(tag, txt, &block)
+    end
+
+    #
+    # If the divert +tag+ exists, divert, otherwise
+    # do nothing.
+    #
+    def try_divert(tag, txt=nil, &block)
+      if @document.has_divert?(tag)
+        divert(tag, txt, &block)
+        true
+      else
+        false
+      end
+    end
+
+    #
+    # Render specific markup only once. For example style and/or
+    # javascript of a component which has many instances.
+    #
+    def once(tag)
+      return if  @document.set.has_key?(tag)
+      @document.set[tag] = true
+      yield if block_given? 
+    end
+
+    HTML_TYPE_CSS = 'text/css'.freeze
+    HTML_REL_STYLESHEET = 'stylesheet'.freeze
+
+    def link_css(url)
+      link.type(HTML_TYPE_CSS).rel(HTML_REL_STYLESHEET).href(url)
+    end
+
+    def new_radio_group
+      Wee::Brush::RadioButtonTag::RadioGroup.new(self)
+    end
+
+    def url_for_callback(callback, type=:action, hash=nil)
+      url_for_callback_id(register_callback(type, callback), hash)
+    end
+
+    def url_for_callback_id(callback_id, hash=nil)
+      if hash
+        build_url(hash.update(:callback_id => callback_id))
+      else
+        build_url(:callback_id => callback_id)
+      end
+    end
+
+    def build_url(*args)
+      @request.build_url(*args)
+    end
+
+    def register_callback(type, callback)
+      cbs = @callbacks
+      if cbs.respond_to?("#{type}_callbacks")
+        cbs.send("#{type}_callbacks").register(@current_component, callback)
+      else
+        raise
+      end
+    end
+
+    protected
+
+    def set_brush(brush)
+      brush.setup(self, @document)
+
+      @current_brush.close if @current_brush
+      @current_brush = brush
+
+      return brush
+    end
+
+    def handle(brush, *args, &block)
+      if block or not args.empty?
+        set_brush(brush)
+        brush.with(*args, &block) 
+      else
+        set_brush(brush)
+      end
+    end
+
+    def handle2(brush, &block)
+      if block
+        set_brush(brush)
+        brush.with(&block) 
+      else
+        set_brush(brush)
+      end
+    end
+
+    alias handle3 set_brush
+
+  end # class HtmlCanvas
+
+end # module Wee

data/lib/wee/html_document.rb

@@ -0,0 +1,52 @@
+require 'wee/html_writer'
+
+module Wee
+
+  #
+  # Represents a complete HTML document.
+  #
+  class HtmlDocument < HtmlWriter
+    def initialize
+      super([])
+    end
+
+    def set
+      @set ||= {}
+    end
+
+    def has_divert?(tag)
+      @divert and @divert[tag]
+    end
+
+    def define_divert(tag)
+      raise ArgumentError if has_divert?(tag)
+      @divert ||= {}
+      @port << (@divert[tag] = [])
+    end
+
+    def divert(tag, txt=nil, &block)
+      raise ArgumentError unless has_divert?(tag)
+      raise ArgumentError if txt and block
+
+      divert = @divert[tag]
+
+      if txt
+        divert << txt
+      end
+
+      if block
+        old_port = @port
+        begin
+          @port = divert
+          block.call
+        ensure
+          @port = old_port
+        end
+      end
+    end
+
+    def to_s
+      @port.join
+    end
+  end
+end

data/lib/wee/html_writer.rb

@@ -0,0 +1,71 @@
+require 'rack'
+
+module Wee
+
+  #
+  # A class used to write out HTML documents easily.
+  #
+  # Usage:
+  #
+  #   w = Wee::HtmlWriter.new(doc='')
+  #   w.start_tag('html')
+  #   w.start_tag('body')
+  #   w.start_tag('a', 'href' => 'http://...')
+  #   w.text('link')
+  #   w.end_tag('a')
+  #   w.end_tag('body')
+  #   w.end_tag('html')
+  #
+  #   p doc  # => '<html><body><a href="http://...">link</a></body></html>'
+  #
+  class HtmlWriter
+
+    attr_accessor :port
+
+    def initialize(port=[])
+      @port = port
+    end
+
+    CLOSING = ">".freeze
+    SINGLE_CLOSING = " />".freeze
+
+    def start_tag(tag, attributes=nil, single=false)
+      if attributes
+        @port << "<#{tag}"
+        attributes.each {|k, v| 
+          if v
+            @port << %[ #{ k }="#{ v }"] 
+          else
+            @port << %[ #{ k }] 
+          end
+        }
+        @port << (single ? SINGLE_CLOSING : CLOSING)
+      else
+        @port << (single ? "<#{tag} />" : "<#{tag}>")
+      end
+    end
+
+    def single_tag(tag, attributes=nil)
+      start_tag(tag, attributes, true)
+    end
+
+    def end_tag(tag)
+      @port << "</#{tag}>"
+    end
+
+    def text(str)
+      @port << str.to_s
+    end
+
+    def encode_text(str)
+      @port << Rack::Utils.escape_html(str.to_s)
+    end
+
+    def write(str)
+      @port << str
+    end
+    alias << write
+
+  end # class HtmlWriter
+
+end # module Wee

data/lib/wee/id_generator.rb

@@ -0,0 +1,81 @@
+module Wee
+
+  #
+  # Abstract base class of all id generators.
+  #
+  class IdGenerator
+    def next
+      raise "subclass responsibility"
+    end
+  end
+
+  #
+  # Sequential id generator.
+  #
+  # Returned ids are guaranteed to be unique, but they are easily guessable.
+  #
+  class IdGenerator::Sequential < IdGenerator
+    def initialize(initial_value=0)
+      @value = initial_value - 1
+    end
+
+    def next
+      (@value += 1).to_s(36)
+    end
+  end
+
+  #
+  # Returned ids are unique with a very high probability and it's
+  # very hard to guess the next or any used id.
+  #
+  class IdGenerator::Secure < IdGenerator
+
+    require 'digest/md5'
+    begin
+      require 'securerandom'
+    rescue LoadError
+    end
+
+    def initialize(salt='wee')
+      @salt = salt
+
+      @use_secure = false
+      if defined?(::SecureRandom)
+        begin
+          @use_secure = true if next_secure != next_secure
+        rescue NotImplementedError
+        end
+      end
+    end
+
+    def next
+      pack(@use_secure ? next_secure : next_md5)
+    end
+
+    protected
+
+    def next_md5
+      now = Time.now
+      dig = Digest::MD5.new
+      dig.update(now.to_s)
+      dig.update(now.usec.to_s)
+      dig.update(rand(0).to_s)
+      dig.update($$.to_s)
+      dig.update(@salt.to_s)
+      dig.digest
+    end
+    
+    def next_secure
+      SecureRandom.random_bytes(16)
+    end
+
+    def pack(str)
+      packed = [str].pack('m')
+      packed.tr!("=\r\n", '')
+      packed.tr!('+/', '-_')
+      packed
+    end
+
+  end
+
+end # module Wee