rabbit 0.6.2

data/lib/rabbit/div/slide-i.erb

@@ -0,0 +1,2 @@
+<a href="./">再読み込み</a>
+<pre><%= rabbit.current_slide_text %></pre>

data/lib/rabbit/div/slide.erb

@@ -0,0 +1,5 @@
+<div class="slide">
+<a href="./">
+<img title="<%= image_title %>" src="<%= image_path(context) %>" />
+</a>
+</div>

data/lib/rabbit/div/tofu.rb

@@ -0,0 +1,309 @@
+require "div/div"
+require "div/tofusession"
+
+require 'rabbit/utils'
+
+module WEBrick
+  class Tofulet
+    def mobile?
+      %r[(DoCoMo|J-PHONE|Vodafone|MOT-|UP\.Browser|DDIPOCKET|ASTEL|PDXGW|Palmscape|Xiino|sharp pda browser|Windows CE|L-mode|WILLCOM)]i =~ @req["user-agent"]
+    end
+  end
+end
+
+module Rabbit
+  module Div
+    module RabbitDiv
+      def initialize(*args)
+        super
+        @cache = {}
+      end
+
+      def to_div_i(context)
+        to_html_i(context)
+      rescue
+        "<p>error! #{h($!)}</p>"
+      end
+
+      def to_html_i(context)
+        to_html(context)
+      end
+
+      private
+      def rabbit
+        @session.rabbit
+      end
+
+      def form2(attrs, method_name, context_or_param, context_or_empty=nil)
+        result = form(method_name, context_or_param, context_or_empty)
+        attrs = attrs.collect do |key, value|
+          "#{h(key)}=\"#{h(value)}\""
+        end.join(" ")
+        result.gsub!(/(<form )/, "\\1#{attrs}")
+        result
+      end
+
+      def param(method_name, add_param, separator=nil)
+        param = make_param(method_name, add_param)
+        ary = param.collect do |k, v|
+          "#{u(k)}=#{u(v)}"
+        end
+        ary.join(separator || h("&"))
+      end
+
+      def ajax_param(method_name, add_js_param=[])
+        result = ''
+        result << param(method_name, {"ajax" => "1"}, "&").dump
+        add_js_param.each do |k|
+          result << " + "
+          result << "&#{u(k)}=".dump
+          result << " + $F(#{u(k).dump})"
+        end
+        result
+      end
+
+      def ajax?(params)
+        params.has_key?("ajax")
+      end
+
+      def uri(method_name, add_param, context)
+        "#{action(context)}?#{param(method_name, add_param)}"
+      end
+
+      def cache_read_file(key, *name)
+        @cache[key] ||= read_file(*name)
+      end
+
+      def read_file(*name)
+        path = Utils.find_path_in_load_path(*name)
+        if path
+          File.read(path)
+        else
+          nil
+        end
+      end
+
+      def to_sjis(str)
+        NKF.nkf("-sWdXm0", str.to_s)
+      end
+    end
+
+    class MainDiv < ::Div::Div
+      include RabbitDiv
+
+      set_erb(File.join("rabbit", "div", "main.erb"))
+      add_erb("to_html_i(context)", File.join("rabbit", "div", "main-i.erb"))
+      reload_erb
+
+      attr_reader :navi
+      def initialize(session)
+        super
+        @slide = SlideDiv.new(session)
+        @navi = NaviDiv.new(session)
+        @comment = CommentDiv.new(session)
+        @js = JSDiv.new(session)
+        @css = CSSDiv.new(session)
+      end
+
+      def on_display(context)
+        if context.mobile?
+          context.res_header("Content-Type", "text/html; charset=Shift_JIS")
+          context.res_body(to_sjis(to_html_i(context)))
+        else
+          context.res_header("Content-Type", "text/html; charset=UTF-8")
+          context.res_body(to_html(context))
+        end
+      end
+    end
+
+    class NaviDiv < ::Div::Div
+      include RabbitDiv
+
+      set_erb(File.join("rabbit", "div", "navi.erb"))
+      add_erb("to_html_i(context)", File.join("rabbit", "div", "navi-i.erb"))
+      reload_erb
+
+      def do_first(context, params)
+        rabbit.move_to_first
+      end
+      
+      def do_previous(context, params)
+        rabbit.move_to_previous_if_can
+      end
+      
+      def do_next(context, params)
+        rabbit.move_to_next_if_can
+      end
+      
+      def do_last(context, params)
+        rabbit.move_to_last
+      end
+
+      private
+      def a_link(context, key, label, label_only)
+        HTML.a_link("<a href=\"#{uri(key, {}, context)}\">", label, label_only)
+      end
+      
+      def first_link(context)
+        a_link(context, "first", h("<<"), rabbit.first_slide?)
+      end
+
+      def previous_link(context)
+        a_link(context, "previous", h("<"), !rabbit.have_previous_slide?)
+      end
+
+      def next_link(context)
+        a_link(context, "next", h(">"), !rabbit.have_next_slide?)
+      end
+
+      def last_link(context)
+        a_link(context, "last", h(">>"), rabbit.last_slide?)
+      end
+    end
+    
+    class CommentDiv < ::Div::Div
+      include RabbitDiv
+
+      set_erb(File.join("rabbit", "div", "comment.erb"))
+      add_erb("to_html_i(context)", File.join("rabbit", "div", "comment-i.erb"))
+      add_erb("to_log_html(context=nil)", File.join("rabbit", "div", "log.erb"))
+      reload_erb
+
+      def initialize(session)
+        super
+        @error_message = nil
+      end
+
+      def do_comment(context, params)
+        comment, = params[comment_param_name]
+        rabbit.append_comment(comment.to_s) do |error|
+          @error_message = error.message
+        end
+        if ajax?(params)
+          context.res_header("Content-Type", "text/html; charset=UTF-8")
+          context.res_body(to_log_html(context))
+          throw(:tofu_done)
+        end
+      end
+
+      private
+      def comments
+        rabbit.comments
+      end
+
+      def comment_param_name
+        "comment"
+      end
+
+      def comment_form_name
+        "comment-form"
+      end
+    end
+
+    class SlideDiv < ::Div::Div
+      include RabbitDiv
+
+      set_erb(File.join("rabbit", "div", "slide.erb"))
+      add_erb("to_html_i(context)", File.join("rabbit", "div", "slide-i.erb"))
+      reload_erb
+
+      def do_current(context, params)
+        context.res_header("Content-Type", "image/#{rabbit.image_type}")
+        context.res_body(rabbit.current_slide_image)
+        throw(:tofu_done)
+      end
+
+      private
+      def image_title
+        title = h(rabbit.slide_title)
+        title << "(#{rabbit.current_slide_number}/"
+        title << "#{rabbit.total_slide_number - 1})"
+        title
+      end
+
+      def image_path(context, name="current", add_param={})
+        uri(name, add_param, context)
+      end
+    end
+
+    class JSDiv < ::Div::Div
+      include RabbitDiv
+
+      set_erb(File.join("rabbit", "div", "js.erb"))
+
+      def do_else(context, params)
+        cmd, = params['div_cmd']
+        content = cache_read_file(cmd, "rabbit", "div", "#{cmd}.js")
+        setup_js_response(context, content)
+      end
+
+      private
+      def setup_js_response(context, js)
+        context.res_header("Content-Type", "text/javascript; charset=UTF-8")
+        context.res_body(js.to_s)
+        throw(:tofu_done)
+      end
+
+      def js_path(context, name, add_param={})
+        uri(name, add_param, context)
+      end
+
+      def script(context, name)
+        src = js_path(context, name)
+        %Q!<script type="text/javascript" src="#{src}"></script>!
+      end
+    end
+
+    class CSSDiv < ::Div::Div
+      include RabbitDiv
+
+      set_erb(File.join("rabbit", "div", "css.erb"))
+
+      def do_else(context, params)
+        cmd, = params['div_cmd']
+        content = cache_read_file(cmd, "rabbit", "div", "#{cmd}.css")
+        setup_css_response(context, content)
+      end
+
+      private
+      def setup_css_response(context, css)
+        context.res_header("Content-Type", "text/css; charset=UTF-8")
+        context.res_body(css.to_s)
+        throw(:tofu_done)
+      end
+
+      def css_path(context, name, add_param={})
+        uri(name, add_param, context)
+      end
+
+      def css_link(context, name)
+        path = css_path(context, name)
+        %Q!<link rel="stylesheet" type="text/css" href="#{path}" />!
+      end
+    end
+
+    class TofuSession < ::Div::TofuSession
+      @@rabbit = nil
+
+      def self.rabbit=(rabbit)
+        @@rabbit = rabbit
+      end
+
+      attr_reader :rabbit
+      def initialize(bartender, hint=nil)
+        super
+        @main = MainDiv.new(self)
+        @rabbit = @@rabbit
+      end
+
+      def do_GET(context)
+        update_div(context)
+        @main.on_display(context)
+      end
+
+      def fetch(ref)
+        super || (@rabbit.accept_move? ? @main.navi : nil)
+      end
+    end
+  end
+end

data/lib/rabbit/element.rb

@@ -0,0 +1,8 @@
+require 'rabbit/utils'
+
+module Rabbit
+  module Element
+    dir = ::File.join("rabbit", "element")
+    Utils.require_files_under_directory_in_load_path(dir)
+  end
+end

data/lib/rabbit/element/base.rb

@@ -0,0 +1,499 @@
+require 'rabbit/utils'
+require 'rabbit/formatter'
+
+require 'rabbit/element/base/draw-hook'
+
+module Rabbit
+  module Element
+    module Base
+      include Utils
+
+      include DrawHook
+      def_draw_hooks :pre, :post, :around
+
+      attr_reader :x, :y, :w, :h
+      attr_reader :px, :py, :pw, :ph
+
+      attr_reader :base_x, :base_y, :base_w, :base_h
+      attr_reader :horizontal_centering, :vertical_centering
+
+      attr_reader :user_property
+
+      attr_accessor :margin_left, :margin_right
+      attr_accessor :margin_top, :margin_bottom
+
+      attr_accessor :padding_left, :padding_right
+      attr_accessor :padding_top, :padding_bottom
+
+      attr_accessor :default_margin_left, :default_margin_right
+      attr_accessor :default_margin_top, :default_margin_bottom
+
+      attr_accessor :default_padding_left, :default_padding_right
+      attr_accessor :default_padding_top, :default_padding_bottom
+
+      attr_accessor :default_visible
+
+      attr_reader :parent, :real_simulation
+
+      def initialize
+        @x = @y = @w = @h = nil
+        @parent = nil
+        @user_property = {}
+        @default_prop = {}
+        init_default_padding
+        init_default_margin
+        init_default_visible
+        clear_theme
+      end
+
+      def parent=(parent)
+        @slide = nil
+        @parent = parent
+      end
+
+      def visible?
+        @visible
+      end
+
+      def slide
+        @slide ||= _slide
+      end
+
+      def draw(simulation=false)
+        x, y, w, h = setup_padding(@x, @y, @w, @h)
+        x, y, w, h = _draw(@canvas, x, y, w, h, simulation)
+        x, w = restore_x_padding(x, w)
+        x, w = restore_x_margin(x, w)
+        x, w = adjust_x_centering(x, w)
+        y, h = adjust_y_padding(y, h)
+        y, h = adjust_y_margin(y, h)
+        [x, y, w, h]
+      end
+
+      def dirty!
+        @dirty = true
+      end
+
+      def dirty?
+        @dirty
+      end
+
+      def wait(*args, &block)
+        slide.register_wait_proc(self, *args, &block) if slide
+      end
+
+      def have_wait_tag?
+        false
+      end
+
+      def compile(canvas, x, y, w, h)
+        @base_x, @base_y, @base_w, @base_h = x, y, w, h
+        @px, @py, @pw, @ph = @x, @y, @w, @h
+        x, y, w, h = setup_margin(x, y, w, h)
+        @canvas, @x, @y, @w, @h = canvas, x, y, w, h
+        if [@px, @py, @pw, @ph] != [@x, @y, @w, @h]
+          dirty!
+        end
+      end
+
+      def compile_for_horizontal_centering(canvas, x, y, w, h)
+        compile(canvas, x, y, w, h)
+      end
+
+      def compile_horizontal(canvas, x, y, w, h)
+        if do_horizontal_centering?
+          do_horizontal_centering(canvas, x, y, w, h)
+        end
+      end
+
+      def prop_set(name, *values)
+        @prop[name] = make_prop_value(name, *values)
+        dirty!
+      end
+      alias __prop_set__ prop_set
+
+      def prop_get(name)
+        @prop[name]
+      end
+      alias __prop_get__ prop_get
+
+      def prop_delete(name)
+        @prop.delete(name)
+        dirty!
+      end
+      alias __prop_delete__ prop_delete
+
+      def add_default_prop(name, value)
+        @default_prop[name] = make_prop_value(name, value)
+      end
+
+      def font(props)
+        props.each do |key, value|
+          key, value = normalize_font_property(key, value)
+          if value
+            prop_set(key, value)
+          else
+            prop_delete(key)
+          end
+        end
+      end
+
+      def inline_element?
+        true
+      end
+
+      def text_renderer?
+        false
+      end
+
+      def substitute_text
+        false
+      end
+
+      def substitute_newline
+        substitute_text do |text|
+          text.gsub(/(\\)?\\n/) {$1 ? "\\n" : "\n"}
+        end
+      end
+
+      def clear_theme
+        @slide = nil
+        @visible = @default_visible
+        @real_simulation = true
+        @width = @height = nil
+        @centering_adjusted_width = nil
+        @centering_adjusted_height = nil
+        @horizontal_centering = @vertical_centering = false
+        @prop = default_prop
+        clear_margin
+        clear_padding
+        clear_draw_procs
+        dirty!
+      end
+
+      def setup_padding(x, y, w, h)
+        x += @padding_left
+        y += @padding_top
+        w -= @padding_left + @padding_right
+        h -= @padding_top + @padding_bottom
+        [x, y, w, h]
+      end
+
+      def restore_x_padding(x, w)
+        x -= @padding_left
+        w += @padding_left + @padding_right
+        [x, w]
+      end
+
+      def restore_x_margin(x, w)
+        x -= @margin_left
+        w += @margin_left + @margin_right
+        [x, w]
+      end
+
+      def adjust_x_centering(x, w)
+        x -= centering_adjusted_width
+        w += centering_adjusted_width
+        [x, w]
+      end
+
+      def adjust_y_padding(y, h)
+        y -= @padding_top
+        h += @padding_top + @padding_bottom
+        [y, h]
+      end
+
+      def setup_margin(x, y, w, h)
+        x += @margin_left
+        y += @margin_top
+        w -= @margin_left + @margin_right
+        h -= @margin_top + @margin_bottom
+        [x, y, w, h]
+      end
+
+      def adjust_y_margin(y, h)
+        y += @margin_bottom
+        h -= @margin_bottom
+        [y, h]
+      end
+
+      def init_default_padding
+        @default_padding_left = 0
+        @default_padding_right = 0
+        @default_padding_top = 0
+        @default_padding_bottom = 0
+      end
+
+      def init_default_margin
+        @default_margin_left = 0
+        @default_margin_right = 0
+        @default_margin_top = 0
+        @default_margin_bottom = 0
+      end
+
+      def init_default_visible
+        @default_visible = !have_wait_tag?
+      end
+
+      def clear_padding
+        @padding_left = @default_padding_left
+        @padding_right = @default_padding_right
+        @padding_top = @default_padding_top
+        @padding_bottom = @default_padding_bottom
+      end
+
+      def clear_margin
+        @margin_left = @default_margin_left
+        @margin_right = @default_margin_right
+        @margin_top = @default_margin_top
+        @margin_bottom = @default_margin_bottom
+      end
+
+      def if_dirty
+        if dirty?
+          yield
+          @dirty = false
+        end
+      end
+
+      def do_horizontal_centering?
+        @horizontal_centering or
+          (parent and parent.do_horizontal_centering?)
+      end
+
+      def do_vertical_centering?
+        @vertical_centering or
+          (parent and parent.do_horizontal_centering?)
+      end
+
+      def horizontal_centering=(new_value)
+        dirty! if @horizontal_centering != new_value
+        @horizontal_centering = new_value
+      end
+
+      def vertical_centering=(new_value)
+        dirty! if @vertical_centering != new_value
+        @vertical_centering = new_value
+      end
+
+      def do_horizontal_centering(canvas, x, y, w, h)
+      end
+
+      def previous_element
+        sibling_element(-1)
+      end
+
+      def next_element
+        sibling_element(1)
+      end
+
+      def available_w
+        @w - @padding_left - @padding_right
+      end
+
+      def width
+        @width + @padding_left + @padding_right
+      end
+
+      def height
+        @height + @padding_top + @padding_bottom
+      end
+
+      def centering_adjusted_width
+        @centering_adjusted_width || 0
+      end
+
+      def centering_adjusted_height
+        @centering_adjusted_height || 0
+      end
+
+      def inspect(verbose=false)
+        if verbose
+          self_info = super()
+        else
+          self_info = "<#{self.class.name}>"
+        end
+        self_info
+      end
+
+      def clone
+        obj = super
+        obj.user_property = @user_property.clone
+        obj.prop = @prop.clone
+        obj
+      end
+
+      def default_prop
+        @default_prop.dup
+      end
+
+      def match?(pattern)
+        pattern === text
+      end
+
+      def margin_set(*values)
+        top, right, bottom, left = parse_four_way(*values)
+        @margin_top = top if top
+        @margin_right = right if right
+        @margin_bottom = bottom if bottom
+        @margin_left = left if left
+      end
+
+      def margin_with(params)
+        margin_set(params)
+      end
+
+      def padding_set(*values)
+        top, right, bottom, left = parse_four_way(*values)
+        @padding_top = top if top
+        @padding_right = right if right
+        @padding_bottom = bottom if bottom
+        @padding_left = left if left
+      end
+
+      def padding_with(params)
+        padding_set(*extract_four_way(params))
+      end
+
+      def show(&block)
+        change_visible(true, &block)
+      end
+
+      def hide(&block)
+        change_visible(false, &block)
+      end
+
+      def [](name)
+        @user_property[name]
+      end
+
+      def []=(name, value)
+        @user_property[name] = value
+      end
+
+      protected
+      def user_property=(prop)
+        @user_property = prop
+      end
+
+      def prop=(prop)
+        @prop = prop
+      end
+
+      private
+      def _slide
+        if @parent
+          @parent.slide
+        else
+          nil
+        end
+      end
+
+      def change_visible(value)
+        visible = @visible
+        @visible = value
+        if block_given?
+          begin
+            yield
+          ensure
+            @visible = visible
+          end
+        end
+      end
+
+      def make_prop_value(name, *values)
+        formatter_name = to_class_name(name)
+        begin
+          unless Format.const_defined?(formatter_name)
+            raise NameError
+          end
+        rescue NameError
+          raise UnknownPropertyError.new(name)
+        end
+        Format.const_get(formatter_name).new(*values)
+      end
+
+      def sibling_element(relative_index)
+        if @parent
+          ind = @parent.elements.index(self)
+          if ind
+            @parent.elements[ind + relative_index]
+          else
+            nil
+          end
+        else
+          nil
+        end
+      end
+
+      def normalize_font_property(key, value)
+        key = key.to_s
+        case key
+        when /\A(family)\z/
+          ["font_#{$1}", value]
+        when /\A(desc)(?:ription)?\z/
+          ["font_#{$1}", value]
+        when /\A(?:foreground|color|fg_color|fg)\z/
+          ["foreground", value]
+        when /\A(?:background|bg_color|bg)\z/
+          ["background", value]
+        when /\A(?:underline|ul)\z/
+          ["underline", value]
+        when /\A(?:underline|ul)_color\z/
+          ["underline_color", value]
+        when /\A(rise|superscript|subscript)\z/
+          value = -value if $1 == "subscript"
+          ["rise", value]
+        when /\A(?:strike[_]?through)\z/
+          value = value ? "true" : "false" unless value.is_a?(String)
+          ["strikethrough", value]
+        when /\A(?:strike[_]?through_color)\z/
+          ["strikethrough_color", value]
+        when /\A(?:fallback)\z/
+          value = value ? "true" : "false" unless value.is_a?(String)
+          ["fallback", value]
+        else
+          [key, value]
+        end
+      end
+
+      def _draw(canvas, x, y, w, h, simulation)
+        around_draw_procs = @around_draw_procs.dup
+        around_draw_procs.concat(slide.waited_draw_procs(self))
+        _draw_rec(canvas, x, y, w, h, simulation, around_draw_procs)
+      end
+
+      def _draw_rec(canvas, x, y, w, h, simulation, around_draw_procs)
+        if around_draw_procs.empty?
+          (@pre_draw_procs +
+           [method(:draw_element)] +
+           @post_draw_procs.reverse).each do |pro,|
+            @real_simulation = simulation
+            _simulation = simulation
+            _simulation = true unless visible?
+            x, y, w, h = pro.call(canvas, x, y, w, h, _simulation)
+          end
+          [x, y, w, h]
+        else
+          @real_simulation = simulation
+          _simulation = simulation
+          _simulation = true unless visible?
+          pro, = around_draw_procs.pop
+          next_proc = Proc.new do |*args|
+            args << around_draw_procs
+            _draw_rec(*args)
+          end
+          pro.call(canvas, x, y, w, h, _simulation, next_proc)
+        end
+      end
+
+      def _indent(str, width="  ")
+        result = ""
+        str.each_line do |line|
+          result << width + line
+        end
+        result
+      end
+    end
+  end
+end