egalite 0.0.1 → 0.0.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Shunichi Arai
+
+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/Rakefile

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

data/egalite.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'egalite/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "egalite"
+  spec.version       = Egalite::VERSION
+  spec.authors       = ["Shunichi Arai"]
+  spec.email         = ["arai@mellowtone.co.jp"]
+  spec.description   = %q{Egalite - yet another web application framework. see description at https://github.com/araipiyo/egalite}
+  spec.summary       = %q{Egalite - yet another web application framework.}
+  spec.homepage      = "https://github.com/araipiyo/egalite"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_dependency "rack"
+end

data/lib/egalite/auth/basic.rb

@@ -0,0 +1,32 @@
+
+module Egalite
+  module Auth
+    class Basic
+      def self.authorize(req,realm)
+        auth = req.authorization
+        return unauthorized(realm) if auth.blank?
+        (method,credentials) = auth.split(' ', 2)
+        return bad_request if method.downcase != "basic"
+        (username,password) = credentials.unpack("m*").first.split(/:/,2)
+        return unauthorized(realm) unless yield(username,password)
+        true
+      end
+      def self.unauthorized(realm)
+        return [ 401,
+          { 'Content-Type' => 'text/plain',
+            'Content-Length' => '0',
+            'WWW-Authenticate' => 'Basic realm="%s"' % realm },
+          []
+        ]
+      end
+      def self.bad_request
+        return [ 400,
+          { 'Content-Type' => 'text/plain',
+            'Content-Length' => '0' },
+          []
+        ]
+      end
+    end
+  end
+end
+

data/lib/egalite/blank.rb

@@ -0,0 +1,53 @@
+# I stole it from ActiveSupport library of Ruby on Rails
+# (MIT License)
+
+class Object
+  # An object is blank if it's nil, empty, or a whitespace string.
+  # For example, "", "   ", nil, [], and {} are blank.
+  #
+  # This simplifies
+  #   if !address.nil? && !address.empty?
+  # to
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/egalite/errorconsole.rb

@@ -0,0 +1,77 @@
+
+class EgaliteErrorController < Egalite::Controller
+  def self.password=(pass)
+    @@password=pass
+  end
+  def self.database=(db)
+    @@database=db
+  end
+  def before_filter
+    return false unless @@password
+    Egalite::Auth::Basic.authorize(req, 'EgaliteError') { |username,password|
+      username == 'admin' and password == @@password
+    }
+  end
+  def get
+    hb = Egalite::HTMLTagBuilder
+    raw("<html><body>" + 
+      hb.ol([ hb.a('latest','�ŐV�G���[�ꗗ'),
+              hb.a('frequent','���p�x�G���[�ꗗ'),
+              hb.a('security','�Z�L�����e�B�G���[�ꗗ'),
+              "<form action='detail'>�G���[�ԍ�: <input type='text' name='id'><input type='submit'></form>",
+      ]) + "</body></html>")
+  end
+  def display(recs)
+    hb = Egalite::HTMLTagBuilder
+    raw("<body><html>" +
+      table_by_array(
+        ['��ʔԍ�(�ڍ�)', '������', '���e', 'URL', '�폜'],
+        recs.map { |rec|
+          [hb.a(url_for(:action => :group, :id => rec[:md5]),rec[:md5]),
+           rec[:count],
+           rec[:text][0..50],
+           rec[:url][0..50],
+           hb.a(url_for(:action => :delete, :id => rec[:md5]),'�폜'),
+          ]
+        }
+      ) + "</body></html>")
+  end
+  def latest(lim)
+    lim ||= 100
+    display(@@database.fetch("SELECT md5, text, url, count(*) as count FROM logs WHERE checked_at is null AND severity != 'security' GROUP BY md5, text, url ORDER BY max(created_at) DESC LIMIT ?",lim.to_i))
+  end
+  def frequent(lim)
+    lim ||= 100
+    display(@@database.fetch("SELECT md5, text, url, count(*) as count FROM logs WHERE checked_at is null AND severity != 'security' GROUP BY md5, text, url ORDER BY count(*) DESC LIMIT ?",lim.to_i))
+  end
+  def security(lim)
+    lim ||= 100
+    display(@@database.fetch("SELECT md5, text, url, count(*) as count FROM logs WHERE checked_at is null AND severity == 'security' GROUP BY md5, text, url ORDER BY count(*) DESC LIMIT ?",lim.to_i))
+  end
+  def group(md5)
+    rec = @@database[:logs].filter(:md5 => md5).first
+    raw("<html><body>"+Egalite::HTMLTagBuilder.ul([
+      rec[:md5],
+      rec[:url],
+      rec[:text],
+    ]) +"</body></html>")
+  end
+  def delete(md5)
+    @@database[:logs].filter(:md5 => md5).update(:checked_at => Time.now)
+    redirect :action => nil
+  end
+  def detail(id)
+    rec = @@database[:logs].filter(:id => id.to_i).first
+    return "no record found." unless rec
+    raw("<html><body>"+Egalite::HTMLTagBuilder.ul([
+      rec[:id],
+      rec[:severity],
+      rec[:created_at],
+      rec[:md5],
+      rec[:ipaddress],
+      rec[:url],
+      rec[:text],
+    ]) +"</body></html>")
+  end
+end
+

data/lib/egalite/helper.rb

@@ -0,0 +1,251 @@
+
+module Egalite
+
+module HTMLTagBuilder
+  def escape_html(s)
+    s.is_a?(NonEscapeString) ? s : NonEscapeString.new(Rack::Utils.escape_html(s))
+  end
+  def _tag(name , soc, attributes)
+    close = soc == :close ? '/' : ''
+    solo = soc == :solo ? '/' : ''
+    
+    atr = if attributes and not attributes.empty?
+      s = attributes.map { |k,v| "#{escape_html(k)}='#{escape_html(v)}'" }.join(' ')
+      " #{s}"
+    else
+      ""
+    end
+    NonEscapeString.new("<#{close}#{escape_html(name)}#{atr}#{solo}>")
+  end
+  def tag_solo(name, attributes = {})
+    _tag(name, :solo, attributes)
+  end
+  def tag_open(name, attributes = {})
+    _tag(name, :open, attributes)
+  end
+  def tag_close(name, attributes = {})
+    _tag(name, :close, attributes)
+  end
+  class <<self
+    include Egalite::HTMLTagBuilder
+    def tag(tag, s, attributes = {})
+      tag_open(tag, attributes) + escape_html(s) + tag_close(tag, {})
+    end
+    %w[br hr].each { |t|
+      define_method(t) { tag_solo(t) }
+    }
+    %w[h1 h2 h3 h4 b i p html body].each { |t|
+      define_method(t) { |s|
+        tag(t, s)
+      }
+    }
+    def a(url, s)
+      tag('a', s, :href=>url)
+    end
+    def li(array)
+      array.map{ |s| "<li>#{escape_html(s)}</li>" }.join("\n")
+    end
+    def ol(array)
+      "<ol>#{li(array)}</ol>"
+    end
+    def ul(array)
+      "<ul>#{li(array)}</ul>"
+    end
+  end
+end
+
+class TableHelper
+ private
+  def self.opt(opts)
+    opts.map { |k,v| " #{escape_html(k)}='#{escape_html(v)}'" }.join
+  end
+  def self.escape_html(s)
+    s.is_a?(NonEscapeString) ? s : Rack::Utils.escape_html(s)
+  end
+  def self._table(header, content, table_opts)
+    head = ""
+    if header
+      head = header.map {|s| "<th>#{escape_html(s)}</th>" }.join
+      head = "  <tr>#{head}</tr>\n"
+    end
+    body = content.map { |line| "  <tr>#{yield(line)}</tr>\n" }
+    NonEscapeString.new("<table#{opt(table_opts)}>\n#{head}#{body}</table>")
+  end
+ public
+  def self.table_by_hash(keys, header, content, table_opts = {})
+    unless keys.size == header.size
+      raise ArgumentError, "key and header count mismatch"
+    end
+
+    _table(header, content, table_opts) { |line|
+      keys.map { |key| "<td>#{escape_html(line[key])}</td>"}.join
+    }
+  end
+  def self.table_by_array(header, content, table_opts = {})
+    _table(header, content, table_opts) { |line|
+      line.map { |s| "<td>#{escape_html(s)}</td>" }.join
+    }
+  end
+end
+
+class FormHelper
+  include HTMLTagBuilder
+
+ private
+  def expand_name(s)
+    s = "#{@param_name}[#{s}]" if @param_name
+    escape_html(s)
+  end
+  def raw(s)
+    NonEscapeString.new(s)
+  end
+
+ public # export just for testing
+
+  def opt(opts)
+    opts.map { |k,v|
+      next "" if [:default,:checked,:selected, :nil].member?(k)
+      " #{escape_html(k)}='#{escape_html(v)}'"
+    }.join
+  end
+  def opt_as_hash(opts)
+    o = opts.dup
+    o.each_key { |k|
+      o.delete(k) if [:default,:checked,:selected, :nil].member?(k)
+    }
+    o
+  end
+
+ public
+
+  def initialize(data = {}, param_name = nil, opts = {})
+    @data = lambda { |k|
+      if data.respond_to?(k)
+        data.send(k)
+      elsif data.respond_to?(:[])
+        data[k]
+      end
+    }
+
+    @param_name = param_name
+    @form_opts = opts
+  end
+  def form(method, url=nil)
+    attrs = opt_as_hash(@form_opts)
+    attrs[:method] = method.to_s.upcase
+    attrs[:action] = url if url
+    tag_open(:form,attrs)
+  end
+  def close
+    tag_close(:form,nil)
+  end
+  def _text(value, name, opts)
+    attrs = opt_as_hash(opts)
+    attrs[:value] = value if value
+    attrs[:size] ||= 30
+    attrs[:type] = 'text'
+    attrs[:name] = expand_name(name)
+    tag_solo(:input, attrs)
+  end
+  def text(name, opts = {})
+    _text(@data[name] || opts[:default], name, opts)
+  end
+  def timestamp_text(name, opts = {})
+    # todo: enable locale
+    # todo: could unify to text()
+    value = @data[name] || opts[:default]
+    value = value.strftime('%Y-%m-%d %H:%M:%S')
+    _text(value,name,opts)
+  end
+  def password(name, opts = {})
+    value = @data[name] || opts[:default]
+    attrs = opt_as_hash(opts)
+    attrs[:value] = value if value
+    attrs[:type] = "password"
+    attrs[:name] = expand_name(name)
+    tag_solo(:input,attrs)
+  end
+  def hidden(name, opts = {})
+    value = @data[name] || opts[:default]
+    attrs = opt_as_hash(opts)
+    attrs[:value] = value if value
+    attrs[:type] = "hidden"
+    attrs[:name] = expand_name(name)
+    tag_solo(:input,attrs)
+  end
+  def checkbox(name, value="true", opts = {})
+    checked = (@data[name] || opts[:default] || opts[:checked])
+    checked = false if @data[name] == false
+    
+    attr_cb = opt_as_hash(opts)
+    attr_cb[:type] = 'checkbox'
+    attr_cb[:name] = expand_name(name)
+    attr_cb[:value] = value
+    attr_cb[:checked] = "checked" if checked
+
+    ucv = opts[:uncheckedvalue] || 'false'
+    attr_h = {:type => 'hidden', :name => expand_name(name), :value => ucv}
+    hidden = opts[:nohidden] ? '' : tag_solo(:input, attr_h)
+    
+    raw "#{hidden}#{tag_solo(:input, attr_cb)}"
+  end
+  def radio(name, choice, opts = {})
+    selected = (@data[name] == choice)
+    selected = (opts[:default] == choice) || opts[:selected] if @data[name] == nil
+    
+    attrs = opt_as_hash(opts)
+    attrs[:selected] = 'selected' if selected
+    attrs[:name] = expand_name(name)
+    attrs[:value] = choice
+    attrs[:type] = 'radio'
+    
+    tag_solo(:input, attrs)
+  end
+  def textarea(name, opts = {})
+    value = escape_html(@data[name] || opts[:default])
+    raw "<textarea name='#{expand_name(name)}'#{opt(opts)}>#{value}</textarea>"
+  end
+  def file(name, opts = {})
+    attrs = opt_as_hash(opts)
+    attrs[:name] = expand_name(name)
+    attrs[:type] = 'file'
+    tag_solo(:input, attrs)
+  end
+  def submit(value = nil, name = nil, opts = {})
+    attrs = opt_as_hash(opts)
+    attrs[:name] = expand_name(name) if name
+    attrs[:value] = value if value
+    attrs[:type] = 'submit'
+    tag_solo(:input, attrs)
+  end
+  def image
+  end
+  def select_by_array(name, options, opts = {})
+    optionstr = options.map {|o|
+      flag = o[0] == @data[name]
+      a = {:value => o[0]}
+      a[:selected] = 'selected' if flag
+      "#{tag_open(:option, a)}#{escape_html(o[1])}</option>"
+    }.join('')
+    
+    raw "<select name='#{expand_name(name)}'#{opt(opts)}>#{optionstr}</select>"
+  end
+  def select_by_association(name, options, optname, opts = {})
+    idname = (opts[:idname] || "id").to_sym
+    optionstr = options.map {|o|
+      flag = o[idname] == @data[name]
+      a = {:value => o[idname]}
+      a[:selected] = 'selected' if flag
+      "#{tag_open(:option, a)}#{escape_html(o[optname])}</option>"
+    }.join('')
+    
+    if opts[:nil]
+      selected = (@data[name] == nil) ? "selected='selected'" : ''
+      optionstr = "<option value='' #{selected}>#{escape_html(opts[:nil])}</option>" + optionstr
+    end
+    
+    raw "<select name='#{expand_name(name)}'#{opt(opts)}>#{optionstr}</select>"
+  end
+end
+
+end

data/lib/egalite/keitai/keitai.rb

@@ -0,0 +1,107 @@
+
+$LOAD_PATH << File.join(File.dirname(__FILE__))
+
+require 'ketai'
+require 'uri'
+require 'openssl'
+require 'base64'
+
+module Egalite
+  module Keitai
+    class URLSession
+      def self.encrypt(s,key)
+        cipher = OpenSSL::Cipher.new("bf-cbc")
+        cipher.pkcs5_keyivgen(key)
+        cipher.encrypt
+        e = cipher.update(s) + cipher.final
+        Base64.encode64(e).tr('+/=','_.-').gsub!("\n","")
+      end
+      def self.decrypt(s,key)
+        cipher = OpenSSL::Cipher.new("bf-cbc")
+        cipher.pkcs5_keyivgen(key)
+        cipher.decrypt
+        e = s.tr('_.-','+/=')
+        e = Base64.decode64(e)
+        d = cipher.update(e) + cipher.final
+        d
+      end
+    end
+    module Session
+      def load_keitai_session(sessionid)
+        session.load_from_param(sessionid)
+      end
+      def modify_url_for_keitai(url,sstr)
+        uri = URI.parse(URI.escape(URI.unescape(url)))
+        return url if not uri.scheme.blank? and uri.scheme !~ /(http|https)/
+        if uri.host and uri.host !~ my_host
+          crypted_url = URLSession.encrypt(url,redirector_crypt_key)
+          File.join(redirector_url,crypted_url)
+        else
+          array = uri.query.to_s.split('&')
+          qhash = array.inject({}) { |a,s| (k,v) = s.split('=',2); a[k] = v; a }
+          qhash['sessionid']=sstr
+          uri.query = qhash.map {|k,v| "#{k}=#{v}"}.join('&')
+          uri.to_s
+        end
+      end
+      def replace_url_for_keitai(body,sstr)
+        body.gsub!(/<a.+?href=(?:'(.+?)'|"(.+?)").+?>/) { |s|
+          url = ($1 || $2)
+          url_after = modify_url_for_keitai(url,sstr)
+          s.sub(url,url_after)
+        }
+        body.gsub!(/(<form.+?>)/) { |s|
+          s + "\n<input type='hidden' name='sessionid' value='#{sstr}'/>\n"
+        }
+      end
+      def redirector_url
+        "/redirector"
+      end
+      def do_after_filter_for_keitai(response,session)
+        code = response[0]
+        headers = response[1]
+        body = response[2].join
+
+        if session and session.sstr
+          sstr = session.sstr
+          if headers['Location']
+            headers['Location'] = modify_url_for_keitai(headers['Location'],sstr)
+          end
+          replace_url_for_keitai(body,sstr)
+          response[2] = [body]
+        end
+        response
+      end
+    end
+    class Controller < Egalite::Controller
+      include Session
+      
+      def before_filter
+        load_keitai_session(params[:sessionid])
+        super
+      end
+      def redirector_crypt_key
+        "Example1"
+      end
+      def my_host
+        /^www.example.com$/
+      end
+      def after_filter(response)
+        do_after_filter_for_keitai(response,session)
+        super(response)
+        response
+      end
+    end
+    
+    class Redirector < Egalite::Controller
+      def get(crypted_url)
+        url = URLSession.decrypt(crypted_url, redirector_crypt_key)
+        "<html><body>外部サイトへ移動しようとしています。以下のリンクをクリックしてください。<br/><br/><a href='#{URI.escape(url)}'>リンク</a></body></html>"
+      end
+      def redirector_crypt_key
+        "Example1"
+      end
+    end
+
+  end
+end

data/lib/egalite/keitai/ketai.rb

@@ -0,0 +1,11 @@
+module Rack::Ketai
+
+  autoload :Middleware, 'rack/ketai/middleware'
+  autoload :Carrier, 'rack/ketai/carrier'
+  autoload :Filter, 'rack/ketai/filter'
+
+  def self.new(app)
+    Middleware.new(app)
+  end
+  
+end