jacktang-hacker-slides 1.0.1

data/lib/hacker_slides/helper.rb

@@ -0,0 +1 @@
+require 'hacker_slides/helper/content_helper'

data/lib/hacker_slides/helper/content_helper.rb

@@ -0,0 +1,46 @@
+module HackerSlides
+  module ContentHelper
+    #
+    #
+    def slides_metadata
+      metadata_str = ''
+      metadata_str << "<title>#{@presentation.title}</title>\n"
+      metadata_str << "<!-- metadata -->\n"
+      metadata_str << "<meta name=\"author\" content=\"#{@presentation.author}\" />\n"
+
+      @presentation.meta.each do |name, value|
+        metadata_str << "<meta name=\"#{name}\" content=\"#{value}\" />\n"
+      end
+      metadata_str << "<meta name=\"generator\" content=\"HackerSlides\" />"
+
+      return metadata_str
+    end
+
+    #
+    #
+    def slides_footer
+     footer = <<EOF 
+<h1>#{@presentation.title}</h1>
+<h2>Time: 
+<script type="text/javascript">
+<!--
+var currentTime = new Date()
+var hours = currentTime.getHours()
+var minutes = currentTime.getMinutes()
+if (minutes < 10){
+minutes = "0" + minutes
+}
+document.write(hours + ":" + minutes + " ")
+if(hours > 11){
+document.write("PM")
+} else {
+document.write("AM")
+}
+//-->
+</script>
+</h2>
+EOF
+      return footer
+    end
+  end
+end

data/lib/hacker_slides/presentation.rb

@@ -0,0 +1,35 @@
+module HackerSlides
+  class Presentation
+
+    attr_accessor :title
+    attr_writer :author
+    attr_writer :version
+    attr_reader :created_at
+    attr_reader :meta
+    attr_reader :total_slides
+
+    def initialize
+      @title = 'Untitled Presentation'
+      @meta = Hash.new
+      @meta[:created_at] = Time.now
+      @total_slides = 0
+    end
+
+    def author
+      return @meta[:author]
+    end
+
+    def version
+      return @meta[:version]
+    end
+
+    def created_at
+      return @meta[:created_at]
+    end
+
+    def incr_slides
+      @total_slides = @total_slides + 1
+    end
+
+  end
+end

data/lib/hacker_slides/version.rb

@@ -0,0 +1,13 @@
+module HackerSlides
+  class Version
+    MAIN  = 1
+    MAJOR = 0
+    MINOR = 1
+
+    class << self
+      def value
+        return "#{MAIN}.#{MAJOR}.#{MINOR}"
+      end
+    end
+  end
+end

data/lib/minitar.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+#--
+# Archive::Tar::Minitar 0.5.2
+#   Copyright 2004 Mauricio Julio Ferna'ndez Pradier and Austin Ziegler
+#
+# This program is based on and incorporates parts of RPA::Package from
+# rpa-base (lib/rpa/package.rb and lib/rpa/util.rb) by Mauricio and has been
+# adapted to be more generic by Austin.
+#
+# It is licensed under the GNU General Public Licence or Ruby's licence.
+#
+# $Id: minitar.rb 213 2008-02-26 22:32:11Z austin $
+#++
+require 'zlib'
+require 'fileutils'
+require 'find'
+
+# = Archive::Tar::Minitar 0.5.2
+# Archive::Tar::Minitar is a pure-Ruby library and command-line
+# utility that provides the ability to deal with POSIX tar(1) archive
+# files. The implementation is based heavily on Mauricio Ferna'ndez's
+# implementation in rpa-base, but has been reorganised to promote
+# reuse in other projects.
+#
+# This tar class performs a subset of all tar (POSIX tape archive)
+# operations. We can only deal with typeflags 0, 1, 2, and 5 (see
+# Archive::Tar::PosixHeader). All other typeflags will be treated as
+# normal files.
+#
+# NOTE::: support for typeflags 1 and 2 is not yet implemented in this
+#         version.
+#
+# This release is version 0.5.2. The library can only handle files and
+# directories at this point. A future version will be expanded to
+# handle symbolic links and hard links in a portable manner. The
+# command line utility, minitar, can only create archives, extract
+# from archives, and list archive contents.
+#
+# == Synopsis
+# Using this library is easy. The simplest case is:
+#
+#   require 'zlib'
+#   require 'archive/tar/minitar'
+#   include Archive::Tar
+#
+#     # Packs everything that matches Find.find('tests')
+#   File.open('test.tar', 'wb') { |tar| Minitar.pack('tests', tar) }
+#     # Unpacks 'test.tar' to 'x', creating 'x' if necessary.
+#   Minitar.unpack('test.tar', 'x')
+#
+# A gzipped tar can be written with:
+#
+#   tgz = Zlib::GzipWriter.new(File.open('test.tgz', 'wb'))
+#     # Warning: tgz will be closed!
+#   Minitar.pack('tests', tgz)
+#
+#   tgz = Zlib::GzipReader.new(File.open('test.tgz', 'rb'))
+#     # Warning: tgz will be closed!
+#   Minitar.unpack(tgz, 'x')
+#
+# As the case above shows, one need not write to a file. However, it
+# will sometimes require that one dive a little deeper into the API,
+# as in the case of StringIO objects. Note that I'm not providing a
+# block with Minitar::Output, as Minitar::Output#close automatically
+# closes both the Output object and the wrapped data stream object.
+#
+#   begin
+#     sgz = Zlib::GzipWriter.new(StringIO.new(""))
+#     tar = Output.new(sgz)
+#     Find.find('tests') do |entry|
+#       Minitar.pack_file(entry, tar)
+#     end
+#   ensure
+#       # Closes both tar and sgz.
+#     tar.close
+#   end
+#
+# == Copyright
+# Copyright 2004 Mauricio Julio Ferna'ndez Pradier and Austin Ziegler
+#
+# This program is based on and incorporates parts of RPA::Package from
+# rpa-base (lib/rpa/package.rb and lib/rpa/util.rb) by Mauricio and
+# has been adapted to be more generic by Austin.
+#
+# 'minitar' contains an adaptation of Ruby/ProgressBar by Satoru
+# Takabayashi <satoru@namazu.org>, copyright 2001 - 2004.
+#
+# This program is free software. It may be redistributed and/or
+# modified under the terms of the GPL version 2 (or later) or Ruby's
+# licence.
+module Archive
+  module Tar
+    module Minitar
+
+      VERSION = "0.5.2"
+
+      # The exception raised when a wrapped data stream class is expected to
+      # respond to #rewind or #pos but does not.
+      class NonSeekableStream < StandardError; end
+      # The exception raised when a block is required for proper operation of
+      # the method.
+      class BlockRequired < ArgumentError; end
+      # The exception raised when operations are performed on a stream that has
+      # previously been closed.
+      class ClosedStream < StandardError; end
+      # The exception raised when a filename exceeds 256 bytes in length,
+      # the maximum supported by the standard Tar format.
+      class FileNameTooLong < StandardError; end
+      # The exception raised when a data stream ends before the amount of data
+      # expected in the archive's PosixHeader.
+      class UnexpectedEOF < StandardError; end
+
+    end
+
+  end
+end
+
+require 'minitar/posix_header'
+require 'minitar/writer'
+require 'minitar/reader'
+require 'minitar/input'
+require 'minitar/output'
+
+

data/lib/minitar/input.rb

@@ -0,0 +1,149 @@
+module Archive
+  module Tar
+    module Minitar
+
+      # Wraps a Archive::Tar::Minitar::Reader with convenience methods and
+      # wrapped stream management; Input only works with random access data
+      # streams. See Input::new for details.
+      class Input
+        include Enumerable
+
+        # With no associated block, +Input::open+ is a synonym for
+        # +Input::new+. If the optional code block is given, it will be passed
+        # the new _writer_ as an argument and the Input object will
+        # automatically be closed when the block terminates. In this instance,
+        # +Input::open+ returns the value of the block.
+        def self.open(input)
+          stream = Input.new(input)
+          return stream unless block_given?
+
+          begin
+            res = yield stream
+          ensure
+            stream.close
+          end
+
+          res
+        end
+
+        # Creates a new Input object. If +input+ is a stream object that responds
+        # to #read), then it will simply be wrapped. Otherwise, one will be
+        # created and opened using Kernel#open. When Input#close is called, the
+        # stream object wrapped will be closed.
+        def initialize(input)
+          if input.respond_to?(:read)
+            @io = input
+          else
+            @io = open(input, "rb")
+          end
+          @tarreader = Archive::Tar::Minitar::Reader.new(@io)
+        end
+
+        # Iterates through each entry and rewinds to the beginning of the stream
+        # when finished.
+        def each(&block)
+          @tarreader.each { |entry| yield entry }
+        ensure
+          @tarreader.rewind
+        end
+
+        # Extracts the current +entry+ to +destdir+. If a block is provided, it
+        # yields an +action+ Symbol, the full name of the file being extracted
+        # (+name+), and a Hash of statistical information (+stats+).
+        #
+        # The +action+ will be one of:
+        # <tt>:dir</tt>::           The +entry+ is a directory.
+        # <tt>:file_start</tt>::    The +entry+ is a file; the extract of the
+        #                           file is just beginning.
+        # <tt>:file_progress</tt>:: Yielded every 4096 bytes during the extract
+        #                           of the +entry+.
+        # <tt>:file_done</tt>::     Yielded when the +entry+ is completed.
+        #
+        # The +stats+ hash contains the following keys:
+        # <tt>:current</tt>:: The current total number of bytes read in the
+        #                     +entry+.
+        # <tt>:currinc</tt>:: The current number of bytes read in this read
+        #                     cycle.
+        # <tt>:entry</tt>::   The entry being extracted; this is a
+        #                     Reader::EntryStream, with all methods thereof.
+        def extract_entry(destdir, entry) # :yields action, name, stats:
+          stats = {
+            :current  => 0,
+            :currinc  => 0,
+            :entry    => entry
+          }
+
+          if entry.directory?
+            dest = File.join(destdir, entry.full_name)
+
+            yield :dir, entry.full_name, stats if block_given?
+
+            if Archive::Tar::Minitar.dir?(dest)
+              begin
+                FileUtils.chmod(entry.mode, dest)
+              rescue Exception
+                nil
+              end
+            else
+              FileUtils.mkdir_p(dest, :mode => entry.mode)
+              FileUtils.chmod(entry.mode, dest)
+            end
+
+            fsync_dir(dest)
+            fsync_dir(File.join(dest, ".."))
+            return
+          else # it's a file
+            destdir = File.join(destdir, File.dirname(entry.full_name))
+            FileUtils.mkdir_p(destdir, :mode => 0755)
+
+            destfile = File.join(destdir, File.basename(entry.full_name))
+            FileUtils.chmod(0600, destfile) rescue nil  # Errno::ENOENT
+
+            yield :file_start, entry.full_name, stats if block_given?
+
+            File.open(destfile, "wb", entry.mode) do |os|
+              loop do
+                data = entry.read(4096)
+                break unless data
+
+                stats[:currinc] = os.write(data)
+                stats[:current] += stats[:currinc]
+
+                yield :file_progress, entry.full_name, stats if block_given?
+              end
+              os.fsync
+            end
+
+            FileUtils.chmod(entry.mode, destfile)
+            fsync_dir(File.dirname(destfile))
+            fsync_dir(File.join(File.dirname(destfile), ".."))
+
+            yield :file_done, entry.full_name, stats if block_given?
+          end
+        end
+
+        # Returns the Reader object for direct access.
+        def tar
+          @tarreader
+        end
+
+        # Closes the Reader object and the wrapped data stream.
+        def close
+          @io.close
+          @tarreader.close
+        end
+
+        private
+        def fsync_dir(dirname)
+          # make sure this hits the disc
+          dir = open(dirname, 'rb')
+          dir.fsync
+        rescue # ignore IOError if it's an unpatched (old) Ruby
+          nil
+        ensure
+          dir.close if dir rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/minitar/output.rb

@@ -0,0 +1,206 @@
+module Archive
+  module Tar
+    module Minitar
+
+      # Wraps a Archive::Tar::Minitar::Writer with convenience methods and
+      # wrapped stream management; Output only works with random access data
+      # streams. See Output::new for details.
+      class Output
+        # With no associated block, +Output::open+ is a synonym for
+        # +Output::new+. If the optional code block is given, it will be passed
+        # the new _writer_ as an argument and the Output object will
+        # automatically be closed when the block terminates. In this instance,
+        # +Output::open+ returns the value of the block.
+        def self.open(output)
+          stream = Output.new(output)
+          return stream unless block_given?
+
+          begin
+            res = yield stream
+          ensure
+            stream.close
+          end
+
+          res
+        end
+
+        # Creates a new Output object. If +output+ is a stream object that
+        # responds to #read), then it will simply be wrapped. Otherwise, one will
+        # be created and opened using Kernel#open. When Output#close is called,
+        # the stream object wrapped will be closed.
+        def initialize(output)
+          if output.respond_to?(:write)
+            @io = output
+          else
+            @io = ::File.open(output, "wb")
+          end
+          @tarwriter = Archive::Tar::Minitar::Writer.new(@io)
+        end
+
+        # Returns the Writer object for direct access.
+        def tar
+          @tarwriter
+        end
+
+        # Closes the Writer object and the wrapped data stream.
+        def close
+          @tarwriter.close
+          @io.close
+        end
+      end
+
+      class << self
+        # Tests if +path+ refers to a directory. Fixes an apparently
+        # corrupted <tt>stat()</tt> call on Windows.
+        def dir?(path)
+          File.directory?((path[-1] == '/') ? path : "#{path}/")
+        end
+
+        # A convenience method for wrapping Archive::Tar::Minitar::Input.open
+        # (mode +r+) and Archive::Tar::Minitar::Output.open (mode +w+). No other
+        # modes are currently supported.
+        def open(dest, mode = "r", &block)
+          case mode
+          when "r"
+            Input.open(dest, &block)
+          when "w"
+            Output.open(dest, &block)
+          else
+            raise "Unknown open mode for Archive::Tar::Minitar.open."
+          end
+        end
+
+        # A convenience method to packs the file provided. +entry+ may either be
+        # a filename (in which case various values for the file (see below) will
+        # be obtained from <tt>File#stat(entry)</tt> or a Hash with the fields:
+        #
+        # <tt>:name</tt>::  The filename to be packed into the tarchive.
+        #                   *REQUIRED*.
+        # <tt>:mode</tt>::  The mode to be applied.
+        # <tt>:uid</tt>::   The user owner of the file. (Ignored on Windows.)
+        # <tt>:gid</tt>::   The group owner of the file. (Ignored on Windows.)
+        # <tt>:mtime</tt>:: The modification Time of the file.
+        #
+        # During packing, if a block is provided, #pack_file yields an +action+
+        # Symol, the full name of the file being packed, and a Hash of
+        # statistical information, just as with
+        # Archive::Tar::Minitar::Input#extract_entry.
+        #
+        # The +action+ will be one of:
+        # <tt>:dir</tt>::           The +entry+ is a directory.
+        # <tt>:file_start</tt>::    The +entry+ is a file; the extract of the
+        #                           file is just beginning.
+        # <tt>:file_progress</tt>:: Yielded every 4096 bytes during the extract
+        #                           of the +entry+.
+        # <tt>:file_done</tt>::     Yielded when the +entry+ is completed.
+        #
+        # The +stats+ hash contains the following keys:
+        # <tt>:current</tt>:: The current total number of bytes read in the
+        #                     +entry+.
+        # <tt>:currinc</tt>:: The current number of bytes read in this read
+        #                     cycle.
+        # <tt>:name</tt>::    The filename to be packed into the tarchive.
+        #                     *REQUIRED*.
+        # <tt>:mode</tt>::    The mode to be applied.
+        # <tt>:uid</tt>::     The user owner of the file. (+nil+ on Windows.)
+        # <tt>:gid</tt>::     The group owner of the file. (+nil+ on Windows.)
+        # <tt>:mtime</tt>::   The modification Time of the file.
+        def pack_file(entry, outputter) #:yields action, name, stats:
+          outputter = outputter.tar if outputter.kind_of?(Archive::Tar::Minitar::Output)
+
+          stats = {}
+
+          if entry.kind_of?(Hash)
+            name = entry[:name]
+
+            entry.each { |kk, vv| stats[kk] = vv unless vv.nil? }
+          else
+            name = entry
+          end
+          
+          name = name.sub(%r{\./}, '')
+          stat = File.stat(name)
+          stats[:mode]   ||= stat.mode
+          stats[:mtime]  ||= stat.mtime
+          stats[:size]   = stat.size
+
+          if RUBY_PLATFORM =~ /win32/
+            stats[:uid]  = nil
+            stats[:gid]  = nil
+          else
+            stats[:uid]  ||= stat.uid
+            stats[:gid]  ||= stat.gid
+          end
+
+          case
+          when File.file?(name)
+            outputter.add_file_simple(name, stats) do |os|
+              stats[:current] = 0
+              yield :file_start, name, stats if block_given?
+              File.open(name, "rb") do |ff|
+                until ff.eof?
+                  stats[:currinc] = os.write(ff.read(4096))
+                  stats[:current] += stats[:currinc]
+                  yield :file_progress, name, stats if block_given?
+                end
+              end
+              yield :file_done, name, stats if block_given?
+            end
+          when dir?(name)
+            yield :dir, name, stats if block_given?
+            outputter.mkdir(name, stats)
+          else
+            raise "Don't yet know how to pack this type of file."
+          end
+        end
+
+        # A convenience method to pack files specified by +src+ into +dest+. If
+        # +src+ is an Array, then each file detailed therein will be packed into
+        # the resulting Archive::Tar::Minitar::Output stream; if +recurse_dirs+
+        # is true, then directories will be recursed.
+        #
+        # If +src+ is an Array, it will be treated as the argument to Find.find;
+        # all files matching will be packed.
+        def pack(src, dest, recurse_dirs = true, &block)
+          Output.open(dest) do |outp|
+            if src.kind_of?(Array)
+              src.each do |entry|
+                pack_file(entry, outp, &block)
+                if dir?(entry) and recurse_dirs
+                  Dir["#{entry}/**/**"].each do |ee|
+                    pack_file(ee, outp, &block)
+                  end
+                end
+              end
+            else
+              Find.find(src) do |entry|
+                pack_file(entry, outp, &block)
+              end
+            end
+          end
+        end
+
+        # A convenience method to unpack files from +src+ into the directory
+        # specified by +dest+. Only those files named explicitly in +files+
+        # will be extracted.
+        def unpack(src, dest, files = [], &block)
+          Input.open(src) do |inp|
+            if File.exist?(dest) and (not dir?(dest))
+              raise "Can't unpack to a non-directory."
+            elsif not File.exist?(dest)
+              FileUtils.mkdir_p(dest)
+            end
+
+            inp.each do |entry|
+              if files.empty? or files.include?(entry.full_name)
+                inp.extract_entry(dest, entry, &block)
+              end
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end