rabbit 2.0.5 → 2.0.6

data/lib/rabbit/command/rabbit.rb

@@ -613,7 +613,7 @@ module Rabbit
         end
 
         options_file = File.join(source, options.options_file)
-        if File.exist?(options_file)
+        if File.file?(options_file)
           options.rest.clear
           console.read_options_file(parser, options, options_file)
         end
@@ -660,7 +660,7 @@ module Rabbit
         rest_arguments = @options.rest
         if @options.source_type == :auto
           if rest_arguments.empty?
-            file_name = choose_source_file_by_dialog(options)
+            file_name = choose_source_file_by_dialog
             exit if file_name.nil?
             rest_arguments = [file_name]
             @options.source_type = Source::File

data/lib/rabbit/console.rb

@@ -69,7 +69,7 @@ module Rabbit
 
       begin
         options_file = options.options_file
-        if options_file and File.exist?(options_file)
+        if options_file and File.file?(options_file)
           read_options_file(parser, options, options_file)
         end
         options.before_hooks.each do |hook|

data/lib/rabbit/element/text-renderer.rb

@@ -256,8 +256,8 @@ module Rabbit
           shadow_layout = canvas.make_layout(shadow_text)
           setup_layout(shadow_layout, @layout.width / Pango::SCALE)
           line_height = shadow_layout.pixel_size[1] / shadow_layout.line_count
-          shadow_x = prop_value("shadow-x") || (line_height * 0.08)
-          shadow_y = prop_value("shadow-y") || (line_height * 0.06)
+          shadow_x = prop_value("shadow-x") || (line_height * 0.03)
+          shadow_y = prop_value("shadow-y") || (line_height * 0.02)
           canvas.draw_layout(shadow_layout, x + shadow_x, y + shadow_y,
                              shadow_color)
         end

data/lib/rabbit/element/video.rb

@@ -0,0 +1,167 @@
+require "rabbit/utils"
+
+require "rabbit/image"
+require "rabbit/element"
+require "rabbit/parser/base"
+require "rabbit/video-window"
+
+module Rabbit
+  module Element
+    class Video
+      include Base
+      include BlockElement
+      include BlockHorizontalCentering
+      include TextRenderer
+
+      attr_reader :filename
+      attr_reader :normalized_width, :normalized_height
+      attr_reader :relative_width, :relative_height
+      attr_reader :relative_margin_top, :relative_margin_bottom
+      attr_reader :relative_margin_left, :relative_margin_right
+      attr_reader :relative_padding_top, :relative_padding_bottom
+      attr_reader :relative_padding_left, :relative_padding_right
+
+      def initialize(filename, prop)
+        @filename = filename
+        prop = Utils.stringify_hash_key(prop)
+        super()
+        normalized_prop = {}
+        prop.each do |name, value|
+          normalized_prop[name.gsub(/-/, '_')] = value
+        end
+        prop = normalized_prop
+        %w(as_large_as_possible).each do |name|
+          instance_variable_set("@#{name}", true_value?(prop[name]))
+        end
+        %w(width height
+           normalized_width normalized_height
+           relative_width relative_height
+           relative_margin_top relative_margin_bottom
+           relative_margin_left relative_margin_right
+           relative_padding_top relative_padding_bottom
+           relative_padding_left relative_padding_right
+          ).each do |name|
+          begin
+            instance_variable_set("@#{name}", prop[name] && Integer(prop[name]))
+          rescue ArgumentError
+            raise InvalidImageSizeError.new(filename, name, prop[name])
+          end
+        end
+
+        resize(@width, @height)
+      end
+
+      alias _compile compile
+      def compile_for_horizontal_centering(canvas, x, y, w, h)
+        _compile(canvas, x, y, w, h)
+      end
+
+      def compile(canvas, x, y, w, h)
+        super
+        adjust_size(canvas, @x, @y, @w, @h)
+      end
+
+      def width
+        @width.to_i + @padding_left + @padding_right
+      end
+
+      def height
+        @height.to_i + @padding_top + @padding_bottom
+      end
+
+      def as_large_as_possible?
+        @as_large_as_possible
+      end
+
+      def draw_element(canvas, x, y, w, h, simulation)
+        unless simulation
+          if canvas.display?
+            @video_window ||= VideoWindow.new(self)
+            @video_window.show(canvas.window)
+          else
+            draw_layout(canvas, x, y)
+          end
+        end
+        [x, y + height, w, h - height]
+      end
+
+      def text
+        "video : #{File.basename(@filename)}"
+      end
+
+      def to_rd
+        text
+      end
+
+      private
+      def adjust_margin(w, h)
+        @margin_top =
+          make_relative_size(@relative_margin_top, h) || @margin_top
+        @margin_bottom =
+          make_relative_size(@relative_margin_bottom, h) || @margin_bottom
+        @margin_left =
+          make_relative_size(@relative_margin_left, w) || @margin_left
+        @margin_right =
+          make_relative_size(@relative_margin_right, w) || @margin_right
+      end
+
+      def adjust_padding(w, h)
+        @padding_top =
+          make_relative_size(@relative_padding_top, h) || @padding_top
+        @padding_bottom =
+          make_relative_size(@relative_padding_bottom, h) || @padding_bottom
+        @padding_left =
+          make_relative_size(@relative_padding_left, w) || @padding_left
+        @padding_right =
+          make_relative_size(@relative_padding_right, w) || @padding_right
+      end
+
+      def adjust_size(canvas, x, y, w, h)
+        base_w = w
+        base_h = h
+        adjust_margin(base_w, base_h)
+        adjust_padding(base_w, base_h)
+        base_h = base_h - @padding_top - @padding_bottom
+        if @as_large_as_possible
+          iw = base_w
+          ih = base_h
+        else
+          nw = make_normalized_size(@normalized_width)
+          nh = make_normalized_size(@normalized_height)
+          rw = make_relative_size(@relative_width, base_w)
+          rh = make_relative_size(@relative_height, base_h)
+          iw = nw || rw || base_w
+          ih = nh || rh || base_h
+        end
+        resize(iw, ih)
+      end
+
+      def resize(w, h)
+        if w.nil? and h.nil?
+          return
+        else
+          w ||= width
+          h ||= height
+        end
+        w = w.ceil if w
+        h = h.ceil if h
+        if w and w > 0 and h and h > 0 and [w, h] != [width, height]
+          @width = w
+          @height = h
+        end
+      end
+
+      def make_normalized_size(size)
+        size && screen_size(size)
+      end
+
+      def make_relative_size(size, parent_size)
+        size && parent_size && ((size / 100.0) * parent_size).ceil
+      end
+
+      def true_value?(value)
+        value == true or value == "true"
+      end
+    end
+  end
+end

data/lib/rabbit/image/pdf.rb

@@ -7,22 +7,29 @@ require "rabbit/image/base"
 module Rabbit
   module ImageManipulable
     class PDF < Base
+      include GetText
 
       unshift_loader(self)
 
       class << self
         def match?(filename)
-          File.open(filename) do |f|
-            line = f.gets
-            line and /\A%PDF-1\.\d\z/ =~ line.chomp
+          return true if File.extname(filename) == ".pdf"
+
+          File.open(filename) do |file|
+            line = file.gets
+            return false if line.nil?
+
+            begin
+              /\A%PDF-1\.\d\z/ =~ line.chomp
+            rescue ArgumentError
+              false
+            end
           end
-        rescue ArgumentError
-          false
         end
       end
 
       def draw(canvas, x, y, params={})
-        if @doc and canvas.poppler_available?
+        if @document and canvas.poppler_available?
           default_params = {
             :width => width,
             :height => height,
@@ -39,21 +46,23 @@ module Rabbit
 
       private
       def page
-        index = self["page"] || 0
+        index = self["page"] || 1
         begin
           index = Integer(index)
         rescue ArgumentError
+          message = _("invalid PDF page number: <%s>") % index.inspect
+          raise ImageLoadError.new("#{@filename}: #{message}")
         end
-        _page = @doc[index]
+        _page = @document[index - 1]
         if _page.nil?
-          message = _("%s page isn't exist in PDF") % index.inspect
+          message = _("%s page doesn't exist in PDF") % index
           raise ImageLoadError.new("#{@filename}: #{message}")
         end
         _page
       end
 
       def update_size
-        @doc = Poppler::Document.new(uri)
+        @document = Poppler::Document.new(uri)
         @width, @height = page.size
       end
 

data/lib/rabbit/parser/ext/video.rb

@@ -0,0 +1,18 @@
+require 'rabbit/element'
+
+module Rabbit
+  module Parser
+    module Ext
+      module Video
+        def make_video(canvas, path, prop)
+          begin
+            Element::Video.new(path, prop)
+          rescue Error
+            canvas.logger.warn($!.message)
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/rd/ext/block-verbatim.rb

@@ -8,6 +8,7 @@ rescue LoadError
 end
 require 'rabbit/parser/rd/ext/base'
 require 'rabbit/parser/rd/ext/image'
+require 'rabbit/parser/rd/ext/video'
 require 'rabbit/parser/ext/enscript'
 require 'rabbit/parser/ext/tex'
 require 'rabbit/parser/ext/aafigure'
@@ -21,6 +22,7 @@ module Rabbit
       module Ext
         class BlockVerbatim < Base
           include Image
+          include Video
           include GetText
 
           def default_ext_block_verbatim(label, source, content, visitor)
@@ -60,6 +62,14 @@ module Rabbit
             end
           end
 
+          def ext_block_verb_video(label, source, content, visitor)
+            return nil unless /^video$/i =~ label
+            src, prop = parse_source(source)
+            return nil if prop['src'].nil?
+
+            make_video(visitor, prop['src'], prop)
+          end
+
           def ext_block_verb_enscript(label, source, content, visitor)
             return nil unless /^enscript (\w+)$/i =~ label
             lang = $1.downcase.untaint

data/lib/rabbit/parser/rd/ext/video.rb

@@ -0,0 +1,15 @@
+require 'rabbit/element'
+require 'rabbit/parser/ext/video'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        module Video
+          include Parser::Ext::Video
+        end
+      end
+    end
+  end
+end
+

data/lib/rabbit/slide-configuration.rb

@@ -32,7 +32,8 @@ module Rabbit
 
     attr_accessor :logger
     attr_accessor :id, :base_name, :tags, :presentation_date
-    attr_accessor :licenses, :slideshare_id, :speaker_deck_id
+    attr_accessor :licenses
+    attr_accessor :slideshare_id, :speaker_deck_id, :ustream_id, :vimeo_id
     attr_writer :version
     attr_accessor :author
     def initialize(logger=nil)
@@ -69,21 +70,25 @@ module Rabbit
       @licenses          = []
       @slideshare_id     = nil
       @speaker_deck_id   = nil
+      @ustream_id        = nil
+      @vimeo_id          = nil
       @author            = nil
     end
 
     def merge!(conf)
-      @id                ||= conf["id"]
-      @base_name         ||= conf["base_name"]
-      @presentation_date ||= conf["presentation_date"]
-      @version           ||= conf["version"]
-      @slideshare_id     ||= conf["slideshare_id"]
-      @speaker_deck_id   ||= conf["speaker_deck_id"]
+      @id                = conf["id"]                || @id
+      @base_name         = conf["base_name"]         || @base_name
+      @presentation_date = conf["presentation_date"] || @presentation_date
+      @version           = conf["version"]           || @version
+      @slideshare_id     = conf["slideshare_id"]     || @slideshare_id
+      @speaker_deck_id   = conf["speaker_deck_id"]   || @speaker_deck_id
+      @ustream_id        = conf["ustream_id"]        || @ustream_id
+      @vimeo_id          = conf["vimeo_id"]          || @vimeo_id
 
       @tags              |=  (conf["tags"] || [])
       @licenses          |=  (conf["licenses"] || [])
 
-      @author = AuthorConfiguration.new(@logger)
+      @author ||= AuthorConfiguration.new(@logger)
       @author.merge!(conf["author"] || {})
     end
 
@@ -97,6 +102,8 @@ module Rabbit
         "licenses"          => @licenses,
         "slideshare_id"     => @slideshare_id,
         "speaker_deck_id"   => @speaker_deck_id,
+        "ustream_id"        => @ustream_id,
+        "vimeo_id"          => @vimeo_id,
       }
       config["author"] = @author.to_hash if @author
       config

data/lib/rabbit/slideshare.rb

@@ -26,6 +26,9 @@ require "rabbit/command/rabbit"
 module Rabbit
   module Task
     class SlideShare
+      class Error < StandardError
+      end
+
       include GetText
 
       BASE_URL = "https://www.slideshare.net"
@@ -33,11 +36,12 @@ module Rabbit
       API_KEY = "NB1B0IzS"
       SHARED_SECRET = "iuTFlPzU"
 
-      attr_accessor :user, :pdf_path, :title, :description, :tags
+      attr_accessor :user, :pdf_path, :id, :title, :description, :tags
       def initialize(logger)
         @logger = logger
         @user = nil
         @pdf_path = nil
+        @id = nil
         @title = nil
         @description = nil
         @tags = []
@@ -50,24 +54,89 @@ module Rabbit
       end
 
       def upload
+        slideshow_id = nil
+        begin
+          slideshow_id = upload_slide
+        rescue Error
+          @logger.error(_("Feailed to upload: %s") % $!.message)
+          return nil
+        end
+
+        begin
+          edit_title(slideshow_id)
+        rescue Error
+          @logger.error(_("Feailed to edit title: %s") % $!.message)
+          return nil
+        end
+
+        url = nil
+        begin
+          url = slide_url(slideshow_id)
+        rescue Error
+          @logger.error(_("Feailed to get slide URL: %s") % $!.message)
+          return nil
+        end
+        url
+      end
+
+      private
+      def upload_slide
         payload = {
           :username              => @user,
           :password              => password,
-          :slideshow_title       => @title,
+          :slideshow_title       => upload_title,
           :slideshow_srcfile     => Faraday::UploadIO.new(@pdf_path,
                                                           "application/pdf"),
           :slideshow_description => @description,
           :tags                  => @tags.join(","),
         }
+        response = post("upload_slideshow", payload)
+        parse_upload_slideshow_response(response)
+      end
+
+      def edit_title(slideshow_id)
+        payload = {
+          :username              => @user,
+          :password              => password,
+          :slideshow_id          => slideshow_id,
+          :slideshow_title       => @title,
+        }
+        response = get("edit_slideshow", payload)
+        parse_edit_slideshow_response(response)
+      end
+
+      def slide_url(slideshow_id)
+        payload = {
+          :slideshow_id => slideshow_id,
+        }
+        response = get("get_slideshow", payload)
+        parse_get_slideshow_response(response)
+      end
+
+      def prepare_payload(payload)
         payload = common_payload.merge(payload)
         payload.keys.each do |key|
           payload.delete(key) if payload[key].nil?
         end
-        parse_response(@connection.post("#{API_PATH_PREFIX}/upload_slideshow",
-                                        payload))
+        payload
+      end
+
+      def get(command, payload)
+        @connection.get(api_url(command), prepare_payload(payload))
+      end
+
+      def post(command, payload)
+        @connection.post(api_url(command), prepare_payload(payload))
+      end
+
+      def api_url(command)
+        "#{API_PATH_PREFIX}/#{command}"
+      end
+
+      def upload_title
+        @id.gsub(/-/, " ")
       end
 
-      private
       def password
         @password ||= read_password(_("Enter password on SlideShare"))
       end
@@ -96,20 +165,31 @@ module Rabbit
         @logger.debug(http_response.body)
 
         unless http_response.success?
-          detail = "#{http_response.status}\n#{http_response.body}"
-          @logger.error(_("Failed to upload: %s") % detail)
-          return nil
+          raise Error, "#{http_response.status}\n#{http_response.body}"
         end
 
-        puts http_response.body
         response = Nokogiri::XML(http_response.body)
         if response.root.name == "SlideShareServiceError"
           message = response.root.elements[0]
-          @logger.error("Failed to upload: %s" % message.text)
-          nil
-        else
-          response.xpath("/SlideShowUploaded/SlideShowID").text.to_i
+          raise Error, message
         end
+
+        response
+      end
+
+      def parse_upload_slideshow_response(http_response)
+        response = parse_response(http_response)
+        response.xpath("/SlideShowUploaded/SlideShowID").text.to_i
+      end
+
+      def parse_edit_slideshow_response(http_response)
+        response = parse_response(http_response)
+        response.xpath("/SlideShowEdited/SlideShowID").text.to_i
+      end
+
+      def parse_get_slideshow_response(http_response)
+        response = parse_response(http_response)
+        response.xpath("/Slideshow/URL").text
       end
     end
   end