egalite 0.0.1 → 0.0.2

data/lib/egalite/session.rb

@@ -0,0 +1,132 @@
+
+require 'openssl'
+
+module Egalite
+class Session
+  attr_accessor :expire_after, :hash, :cookie_name
+
+  def initialize(env, cookies, opts = {})
+    @env = env
+    @cookies = cookies
+    @cookie_name = opts[:cookie_name] || 'egalite_session'
+    @expire_after = opts[:expire_after] || (86400 * 30)
+    @secure = opts[:secure] || false
+    @path = opts[:path] || '/'
+    @hash = {}
+    @loaded = false
+  end
+  def create
+    raise NotImplementedError
+  end
+  def load
+    raise NotImplementedError
+  end
+  def save
+    raise NotImplementedError
+  end
+  def delete
+    raise NotImplementedError
+  end
+  def [](k)
+    @hash[k]
+  end
+  def []=(k,v)
+    @hash[k] = v
+  end
+end
+class SessionSequel < Session
+  def self.create_table(db, opts = {})
+    table = opts[:table_name] || :sessions
+    
+    db.create_table(table) {
+      primary_key :id, :integer, :auto_increment => true
+      column :mac, :varchar
+      column :updated_at, :timestamp
+    }
+  end
+
+  def initialize(env, cookies, opts = {}) 
+    @db = env.db
+    @table = opts[:tablename] || :sessions
+    
+    super(env, cookies, opts)
+  end
+  def cookie
+    {
+      :value => @sstr,
+      :expires => Time.now + @expire_after,
+      :path => @path,
+      :secure => @secure
+    }
+  end
+  def sstr
+    @sstr
+  end
+  def _load(_sstr)
+    return false unless _sstr and _sstr.size > 0
+    (sid,mac) = _sstr.split(/_/)
+
+    sid = sid.to_i
+    return false if sid <= 0
+    return false unless mac and mac.size > 0
+
+    rec = @db[@table][:id => sid]
+    return false unless rec and rec[:mac] == mac
+    
+    # timeout check
+    updated = rec[:updated_at]
+    return false if Time.now > (updated + @expire_after)
+    
+    @sstr = _sstr
+    @hash = rec
+    @sid = sid
+    @mac = mac
+    @loaded = true
+    @cookies[@cookie_name] = cookie
+    
+    @db[@table].filter(:id => sid).update(:updated_at => 'now')
+
+    true
+  end
+  def load_from_param(_sstr)
+    _load(_sstr)
+  end
+  def load
+    _sstr = @cookies[@cookie_name]
+    _sstr = _sstr[0] if _sstr.is_a?(Array)
+    _load(_sstr)
+  end
+  def create(hash = nil)
+    @sid = @db[@table].insert({})
+    @mac = OpenSSL::Random.random_bytes(8).unpack('h*')[0]
+    hash ||= {}
+    @db[@table].filter(:id => @sid).update(hash.merge(:mac => @mac,:updated_at => Time.now))
+    @hash = @db[@table][:id => @sid]
+
+    @sstr = "#@sid" + "_#@mac"
+    @cookies[@cookie_name] = cookie
+    @loaded = true
+
+    true
+  end
+  def delete
+    @cookies[@cookie_name] = {
+      :value => nil,
+      :expires => Time.now - 3600,
+      :path => @path,
+      :secure => @secure
+    }
+    @db[@table].filter(:id => @sid).delete
+    @loaded = false
+    true
+  end
+  def save
+    return false unless @loaded
+    [:updated_at, :mac, :id].each { |s| @hash.delete(s) }
+    @db[@table].filter(:id => @sid).update(
+      {:updated_at => Time.now}.merge(@hash)
+    )
+    true
+  end
+end
+end # module

data/lib/egalite/stringify_hash.rb

@@ -0,0 +1,63 @@
+# used with http parameters
+# simpler version of HashWithIndifferentAccess of Ruby on Rails
+
+module Egalite
+class StringifyHash < Hash
+  def self.create(values)
+    hash = self.new
+    hash.update(values)
+    hash
+  end
+  def [](k)
+    super(stringify(k))
+  end
+  def []=(k,v)
+    super(stringify(k),v)
+  end
+  def update(hash)
+    newhash = {}
+    hash.each { |k,v|
+      newhash[stringify(k)] = v
+    }
+    super(newhash)
+  end
+  alias_method :merge!, :update
+
+  def key?(key)
+    super(stringify(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  def fetch(key, *extras)
+    super(stringify(key), *extras)
+  end
+
+  def values_at(*indices)
+    indices.collect {|key| self[key]}
+  end
+
+  def dup
+    StringifyHash.create(self)
+  end
+
+  def merge(hash)
+    dup.update(hash)
+  end
+
+  def delete(key)
+    super(stringify(key))
+  end
+
+  # Convert to a Hash with String keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+private
+  def stringify(key)
+    key.kind_of?(Symbol) ? key.to_s : key
+  end
+end
+end

data/lib/egalite/support.rb

@@ -0,0 +1,35 @@
+# Egalite support methods
+
+class Hash
+  def <<(b)
+    merge(b.to_hash)
+  end
+  def >>(b)
+    b.to_hash.merge(self)
+  end
+end
+
+class NilClass #:nodoc:
+  def size
+    0
+  end
+end
+
+# <<from ActiveSupport library of Ruby on Rails>>
+# (MIT License)
+
+# Tries to send the method only if object responds to it. Return +nil+ otherwise.
+# 
+# ==== Example :
+# 
+# # Without try
+# @person ? @person.name : nil
+# 
+# With try
+# @person.try(:name)
+class Object
+  def try(method)
+    send(method) if respond_to?(method, true)
+  end
+end
+

data/lib/egalite/template.rb

@@ -0,0 +1,287 @@
+require 'jcode'
+
+module Egalite
+
+class NonEscapeString < String
+  def +(b)
+    NonEscapeString.new(super(HTMLTagBuilder.escape_html(b)))
+  end
+end
+
+class HTMLTemplate
+  RE_NEST = /<(group|if|unless)\s+name=['"](.+?)['"]>/i
+  RE_ENDNEST = /<\/(group|if|unless)>/i
+  RE_PLACE = /&=([.-_0-9a-zA-Z]+?);/
+  RE_INPUT = /<input\s+(.+?)>/im
+  RE_SELECT = /<select\s+name\s*=\s*['"](.+?)['"](.*?)>\s*<\/select>/im
+  
+  RE_A = /<a\s+(.+?)>/im
+  RE_FORM = /<form\s+(.+?)>/im
+
+  RE_INCLUDE = /<include\s+(.+?)\/>/i
+  RE_PARENT = /<parent\s+name=['"](.+?)['"]\s*\/>/i
+  RE_YIELD = /<yield\/>/i
+  
+  attr_accessor :controller, :default_escape
+  
+  def initialize
+    @default_escape = true
+    @controller = nil
+  end
+  
+  private
+  
+  def parse_tag_attributes(attrs)
+    a = attrs.split(/(\:?\w+(!:[^=])|\:?\w+=(?:'[^']+'|"[^"]+"|\S+))\s*/)
+    a = a.select { |s| s != "" }
+    hash = {}
+    a.each { |s|
+      b = s.split('=',2)
+      b[0].sub!(/\s$/,'')
+      b[1] = b[1][1..-2] if b[1] and (b[1][0,1] == '"' or b[1][0,1] == "'")
+      hash[b[0]] = b[1] || true
+    }
+    hash
+  end
+  def attr_colon(attrs)
+    colons = {}
+    attrs.each { |k,v| colons[k[1..-1]] = v if k =~ /^\:/ }
+    str = attrs.select { |k,v| k !~ /^\:/ }.map { |k,v| "#{k}='#{v}'" }.join(' ')
+    [colons, str]
+  end
+  
+  def dotchain(values, name)
+    dots = name.split('.').select {|s| not s.empty? }
+    
+    value = values
+    dots.each { |key|
+      value = if not value.is_a?(Hash) and value.respond_to?(key)
+        value.send(key)
+      elsif value.respond_to?(:[])
+        value[key] || value[key.to_sym]
+      end
+      break unless value
+    }
+    value
+  end
+
+  #
+  # tags
+  #
+  def placeholder(html, params)
+    html.gsub!(RE_PLACE) {
+      key = $1
+      if params[key].is_a?(NonEscapeString) or not @default_escape
+        params[key]
+      else
+        escapeHTML(params[key])
+      end
+    }
+  end
+  def input_tag(html, params)
+    html.gsub!(RE_INPUT) { |s|
+      attrs = parse_tag_attributes($1)
+      next s if attrs['checked'] or attrs['selected']
+      name = attrs['name']
+      next s unless name
+      case attrs['type']
+        when 'text'
+         next s if attrs['value']
+         s.sub!(/\/?>$/," value='"+escapeHTML(params[name])+"'/>") if params[name]
+        when 'hidden'
+         next s if attrs['value']
+         s.sub!(/\/?>$/," value='"+escapeHTML(params[name])+"'/>") if params[name]
+        when 'radio'
+          s.sub!(/\/?>$/," checked/>") if (params[name].to_s == attrs['value'])
+        when 'checkbox'
+          s.sub!(/\/?>$/," checked/>") if params[name]
+      end
+      s
+    }
+  end
+  def a_tag(html, params)
+    html.gsub!(RE_A) { |s|
+      attrs = parse_tag_attributes($1)
+      next s if attrs['href']
+      next s unless @controller
+      
+      (colons, noncolons) = attr_colon(attrs)
+      next s if colons.empty?
+      # when :hoge=$foo, expand hash parameter ['foo']
+      colons.each { |k,v|
+        next if v[0,1] != '$'
+        val = params[v[1..-1]]
+        colons[k] = val
+      }
+      colons = StringifyHash.create(colons)
+      link = @controller.url_for(colons)
+      "<a href='#{link}' #{noncolons}>"
+    }
+  end
+  def form_tag(html,params)
+    html.gsub!(RE_FORM) { |s|
+      attrs = parse_tag_attributes($1)
+      next s if attrs['action']
+      next s unless @controller
+      
+      (colons, noncolons) = attr_colon(attrs)
+      next s if colons.empty?
+      colons = StringifyHash.create(colons)
+      link = @controller.url_for(colons)
+      "<form action='#{link}' #{noncolons}>"
+    }
+  end
+  def select_tag(html,params)
+    html.gsub!(RE_SELECT) { sel = "<select name='#$1'#$2>"
+      if (params[$1] and params[$1].is_a?(Array))
+        params[$1].each_index() { |key|
+          next if (key == 0)
+          selected = " selected" if params[$1][0] == key
+          value = params[$1][key]
+          sel << "<option value='#{key}'#{selected}>"
+          sel << escapeHTML(value)
+          sel << "</option>" unless @keitai
+        }
+      end
+      sel << "</select>"
+    }
+  end
+  
+  #
+  # main routines
+  #
+  
+  def nonnestedtags(html, params)
+    placeholder(html,params)
+    input_tag(html,params)
+    a_tag(html,params)
+    form_tag(html,params)
+    select_tag(html,params)
+
+    # parse include tag
+    if block_given?
+      html.gsub!(RE_INCLUDE) {
+        attrs = parse_tag_attributes($1)
+        attrs.each { |k,v| attrs[k[1..-1]] = v if k =~ /^\:/ }
+        yield(attrs)
+      }
+      parent = nil
+      md = RE_PARENT.match(html)
+      parent = md[1] if md
+      html.gsub!(RE_PARENT,"")
+      if parent
+        txt = yield(parent)
+        txt.gsub!(RE_YIELD, html)
+        html = txt
+      end
+    end
+    html
+  end
+
+  def keyexpander(params, parent_params)
+    lambda { |k|
+      if k[0,1] == '.'
+        dotchain(params, k)
+      else
+        if params[k] == nil
+          if params[k.to_sym] == nil
+            parent_params[k]
+          else
+            params[k.to_sym]
+          end
+        else
+          params[k]
+        end
+      end
+    }
+  end
+
+  def string_after_outermost_closetag(html)
+    while md1 = RE_NEST.match(html)
+      break if (RE_ENDNEST.match(md1.pre_match))
+      html = string_after_outermost_closetag(md1.post_match)
+    end
+    RE_ENDNEST.match(html).post_match
+  end
+  
+  public
+  
+  def escapeHTML(s)
+    s.to_s.gsub(/&/n, '&amp;').gsub(/'/n,'&#039;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;')
+  end
+  
+  def handleTemplate(html, orig_values, parent_params={}, &block)
+    params = keyexpander(orig_values, parent_params)
+    
+    # parse group tag and recurse inner loop
+    while md1 = RE_NEST.match(html) # beware: complicated....
+      # break if it is innermost loop.
+      break if (RE_ENDNEST.match(md1.pre_match))
+
+      # obtain a length of outermost group tag.
+      post = string_after_outermost_closetag(md1.post_match)
+      
+      tag = md1[1]
+      key = md1[2]
+      
+      # recursive-call for each element of array
+      innertext = ""
+      case tag.downcase
+        when 'group'
+          groupval = params[key]
+          groupval = [] if (groupval == nil)
+          groupval = [groupval] unless (groupval.is_a?(Array))
+          groupval.each { |v| 
+            innertext << handleTemplate(md1.post_match, v, params)
+          }
+        when 'if'
+          unless params[key].blank?
+            innertext << handleTemplate(md1.post_match, orig_values, parent_params)
+          end
+        when 'unless'
+          if params[key].blank?
+            innertext << handleTemplate(md1.post_match, orig_values, parent_params)
+          end
+        else
+          raise
+      end
+      # replace this group tag
+      html[md1.begin(0)..-(post.size+1)] = innertext
+    end
+    # cutoff after end tag, in inner-most loop.
+    md1 = RE_ENDNEST.match(html)
+    html = md1.pre_match if (md1)
+
+    nonnestedtags(html, params, &block)
+  end
+end
+
+class CSRFTemplate < HTMLTemplate
+  RE_FORM = /<form\s+([^>]+?)>(?!\s*<input type='hidden' name='csrf')/im
+
+  def form_tag(html,params)
+    html.gsub!(RE_FORM) { |s|
+      formtag = s
+      attrs = parse_tag_attributes($1)
+      csrf = nil
+      if attrs[":nocsrf"]
+        attrs.delete(":nocsrf")
+      elsif attrs["method"] =~ /\APOST\Z/i
+        csrf = params["csrf"]
+        csrf = "<input type='hidden' name='csrf' value='#{escapeHTML(csrf)}'/>"
+      end
+      
+      if (not attrs['action']) and @controller
+        (colons, noncolons) = attr_colon(attrs)
+        unless colons.empty?
+          colons = StringifyHash.create(colons)
+          link = @controller.url_for(colons)
+          formtag = "<form action='#{link}' #{noncolons}>"
+        end
+      end
+      "#{formtag}#{csrf}"
+    }
+  end
+end
+
+end # end module

data/lib/egalite/version.rb

@@ -0,0 +1,3 @@
+module Egalite
+  VERSION = "0.0.2"
+end