epubforge 0.0.5

data/lib/utils/directory_builder.rb

@@ -0,0 +1,181 @@
+module EpubForge
+  module Utils
+    class DirectoryBuilder
+      attr_accessor :current_path, :current_file
+      
+      def initialize( path )
+        @paths = []
+        @current_path = path.fwf_filepath
+        make_path
+      end
+      
+      def self.create( path, &block )
+        builder = self.new( path )
+        yield builder if block_given?
+        builder
+      end
+      
+      def dir( *args, &block )
+        descend( *args ) do
+          yield if block_given?
+        end
+      end
+      
+      # block must be given
+      def self.tmpdir( &block )
+        if block_given?
+          Dir.mktmpdir do |dir|
+            self.create( dir ) do |builder|
+              yield builder
+            end
+          end
+        else
+          self.create( Dir.mktmpdir )
+        end
+      end
+      
+      # Copies the given source file into a file in the current_path.
+      # If a dest_name is given, the new file will be given that name.
+      def copy( src_filepath, dst_name = nil )
+        dst_filepath = dst_name ? @current_path.join( dst_name ) : @current_path
+        FileUtils.copy( src_filepath, dst_filepath )
+      end
+      
+      def file( name = nil, content = nil, &block )
+        # if name && content
+        #   begin
+        #     f = open_file( name )
+        #     f << content
+        #   ensure
+        #     close_file
+        #   end
+        if name
+          open_file( name )
+          @current_file << content if content
+          if block_given?
+            begin
+              yield @current_file
+            ensure
+              close_file
+            end
+          end
+        else
+          @current_file
+        end
+      end
+      
+      def current_file
+        @current_file ? FunWith::Files::FilePath.new( @current_file.path ) : nil
+      end
+      
+      # if file not given, the result is appended to the current file.
+      def download( url, file = nil )
+        if file
+          if file.fwf_filepath.relative?
+            file = FunWith::Files::FilePath.new( @current_path, file )
+          end
+            
+          File.open( file, "w" ) do |f|
+            download_to_target( url, f )
+          end
+        elsif @current_file
+          download_to_target( url, @current_file )
+        else
+          puts "No current file to append #{url} to."
+        end
+      end
+
+      def template( src, dst, vars = {} )
+        self.file( dst ) do |f|
+          f << Utils::TemplateEvaluator.new( src, vars ).result
+        end
+      end
+      
+      protected
+      def make_path
+        FileUtils.mkdir_p( @current_path ) unless @current_path.exist?
+      end
+
+      def descend( *args, &block )
+        if @current_path.directory?
+          close_file
+  	      @paths << @current_path
+          @current_path = @paths.last.join( *args )
+          make_path
+  	      yield
+          @current_path = @paths.pop
+          close_file
+        else
+          raise "Cannot descend."
+        end
+      end 
+      
+      def open_file( name )
+        close_file
+        @current_file = File.open( @current_path.join( name ), "w" )
+      end
+      
+      def close_file
+        if @current_file
+          @current_file.flush
+          @current_file.close
+        end
+        
+        @current_file = nil
+      end
+      
+      def download_to_target( url, file )
+        Downloader.new.download( url, file )
+      end
+    end
+  end
+end
+
+
+# sample code
+# 
+# DirBuilder.create( '~/project' ) do |b|         # starts by creating directory.  If parent 
+#                                                 # directories don't exist, they will soon.
+#                                                 # if you use DirBuilder.tmp('~/project'), a tempdir
+#                                                 # is created, and its contents relocated to ~/project when the
+#                                                 # block terminates.
+#   b.dir("images") do                      # creates subdirectory "images"
+#     for img in src_dir.entries.select{|img| img.extension == ".png"}
+#     b.copy( src_dir.join( img.filename ) )         # copies a bunch of files from another directory
+#   end    # rises back to the initial '~/project directory
+# 
+#   b.copy( src_dir.join( "rorshach.xml" ) )
+#   b.download( "dest.bash", "http://get.rvm.io" )            # downloads file directly beneath '~/project'
+#                                                             # maybe someday, though
+# 
+#   b.dir("text", "scenes") do   # creates ~/project/text/scenes subdir
+#     b.file( "adventure_time.txt" ) do |f|
+#       f << "Fill this in later"
+#     end
+# 
+#     # calling .file without feeding it a block leaves it open for writing,
+#     # until either the enclosing block terminates or .file is called
+#     # again with a string argument.
+#     b.file( "another_brick.txt" )           
+#     b.file << "Hey, you!"
+#     b.file << "Yes, you!"
+#     b.file.push "Stand still, laddie!"
+#     
+#     b.template(templates_dir.join("blue_template.txt")) do |t|
+#       t.var(:fname, "John")
+#       t.var(:lname, "Macey")
+#       t.var(:state, "Ohio")
+#       t.vars(graduated: "2003")
+#       t.vars(quot: "That wasn't my duck.", photo: "john.png", css: "font-family: arial")
+#     end
+# 
+#     b.copy( [src_dir.join("abba.txt"), "baab.txt"] )  # contents of abba.txt copied into baab.txt
+#   
+#     
+#     b.file( ".lockfile" )   # creates an empty file
+#   end
+# 
+#   b.
+# end
+#   
+  

data/lib/utils/downloader.rb

@@ -0,0 +1,58 @@
+module EpubForge
+  module Utils
+    class Downloader
+      # stolen from:
+      # http://stackoverflow.com/questions/2263540/how-do-i-download-a-binary-file-over-http-using-ruby
+      def download( url, io )
+        @uri = URI.parse( url )
+        @io  = io
+        
+        open( url ) do |f|
+          @io << f.read
+        end
+        
+        # @io << Net::HTTP.get( @uri )
+        
+        # Net::HTTP.start( @uri.host, @uri.port ) do |http| 
+        #   http.request_get( @uri.path ) do |request| 
+        #     request.read_body do |seg|
+        #       puts "==============================  #{seg} ============================="
+        #       io << seg
+        #       #hack -- adjust to suit:
+        #       sleep 0.005 
+        #     end
+        #   end
+        # end
+      rescue Exception => e
+        handle_network_errors( e )
+      end
+      
+      def handle_network_errors( e )
+        raise e
+      rescue URI::InvalidURIError => e
+        puts "Tried to get #{@uri.path} but failed with URI::InvalidURIError."
+      rescue OpenURI::HTTPError => e
+        STDERR.write( "Couldn't fetch podcast info from #{@uri.path}\n" )
+        STDERR.write( "#{e}\n\n" )
+      rescue SocketError => e
+        STDERR.write( "Problem connecting to server (Socket error) when downloading #{@uri.path}." )
+        STDERR.write( "#{e}\n\n" )
+      rescue URI::InvalidURIError => e
+        STDERR.write( "URI::InvalidURIError for #{@uri.path}." )
+        STDERR.write( "#{e}\n\n" )
+        # this may be too broad a filter
+        # TODO: retry?
+      rescue SystemCallError => e
+        STDERR.write( "Problem connecting to server (System call error) when downloading #{@uri.path}" )
+        STDERR.write( "#{e}\n\n" )
+      rescue OpenSSL::SSL::SSLError => e
+        STDERR.write( "OpenSSL::SSL::SSLError while downloading #{@uri.path}" )
+        STDERR.write( "#{e}\n\n" )
+      # rescue Timeout::Error
+      #   STDERR.write( "Timeout error connecting to #{@uri.path}" )
+      #   STDERR.write( "#{e}\n\n" )
+      end
+    end
+  end
+end
+

data/lib/utils/file_orderer.rb

@@ -0,0 +1,45 @@
+module EpubForge
+  module Utils
+    
+    # FileOrderer holds a set of strings/regexes, then reorders a set of files (FunWith::Files::FilePaths, actually)
+    # by matching the filenames against one regex after another.  Allows you to say,
+    # "I want the title page, the foreward, then all the chapters, then all the appendixes, then the afterword."
+    # Ex:  FileOrderer( ["title_page", "forward", "chapter-.*", "afterword", "appendix.*" ).reorder( pages )
+    # Only compares the basename minus extension.  Files should come from the same directory
+    class FileOrderer
+      def initialize( matchers )
+        @matchers = matchers.map do |m| 
+          case m
+          when Regexp
+            m
+          when String
+            /^#{m}$/
+          end
+        end
+        
+        @matchers.push( /^.*$/ )
+      end
+      
+      def reorder( files )
+        files = files.map(&:fwf_filepath)
+        
+        files.sort_by!{ |f|
+          f.basename_no_ext.to_s  
+        }
+        
+        
+        ordered_files = @matchers.inject( [] ) do |collector, matcher|
+          matched_files = files.select do |f| 
+            name = f.basename_no_ext.to_s
+            matcher.match( name )
+          end
+
+          collector += matched_files
+          files -= matched_files
+  
+          collector
+        end
+      end
+    end
+  end
+end

data/lib/utils/file_path.rb

@@ -0,0 +1,152 @@
+module EpubForge
+  module Utils
+    class FilePath < Pathname
+      def initialize( *args )
+        super( File.join( *args ) )
+      end
+
+      # args implicitly joined to cwd
+      def self.cwd( *args )
+        Dir.pwd.fwf_filepath.join( *args )
+      end
+      
+      def self.pwd( *args )
+        self.cwd( *args )
+      end
+
+      def join( *args, &block )
+        if block_given?
+          yield self.class.new( super(*args) )
+        else
+          self.class.new( super(*args) )
+        end
+      end
+
+      alias :exists? :exist?
+      
+      def up
+        self.class.new( self.join("..") ).expand
+      end
+      
+      # opts:
+      #    :class  =>  [self.class] The class of objects you want returned (String, FilePath, ClassLoader, etc.)
+      #                Should probably be a subclass of FilePath or String.  Class.init must accept a string
+      #                [representing a file path] as the sole argument.
+      #
+      #    :recurse => [false] 
+      #    :ext => []  A single symbol, or a list containing strings/symbols representing file name extensions.
+      #                No leading periods kthxbai.
+      #     
+      #    If opts not given, the user can still do it explicitly with arguments like .glob("**", "*.rb")           
+      def glob( *args )
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        
+        recurser = opts[:recurse] ? "**" : nil
+        extensions = case opts[:ext]
+        when Symbol, String
+          "*.#{opts[:ext]}"
+        when Array
+          extensions = opts[:ext].map(&:to_s).join(',')
+          "*.{#{extensions}}"
+        when NilClass
+          nil
+        end
+        
+        args += [recurser, extensions]
+        args.compact!
+        
+        opts[:class] ||= self.class
+        Dir.glob( self.join(*args) ).map{ |f| opts[:class].new(f) }
+      end
+      
+      def expand
+        self.class.new( File.expand_path( self ) )
+      end
+
+      def touch
+        FileUtils.touch( self )
+        return true
+      rescue Errno::EACCESS
+        return false
+      end
+      
+      def touch_dir
+        FileUtils.mkdir_p( self )
+        return true
+      rescue Errno::EEXIST
+        return true
+      rescue Errno::EACCESS
+        return false
+      end
+      
+      def write( content = nil, &block )
+        File.open( self, "w" ) do |f|
+          f << content if content
+          if block_given?
+            yield f
+          end
+        end
+      end
+      
+      def append( content = nil, &block )
+        File.open( self, "a" ) do |f|
+          f << content if content
+          if block_given?
+            yield f
+          end
+        end
+      end
+      
+      def grep( regex )
+        return [] unless self.file?
+        matching = []
+        self.each_line do |line|
+          matching.push( line ) if line.match( regex )
+        end
+        matching
+      end
+
+      # Not the same as zero?
+      def empty?
+        raise Exceptions::FileDoesNotExist unless self.exist?
+        
+        if self.file?
+          File.size( self ) == 0
+        elsif self.directory?
+          self.glob( "**", "*" ).length == 0
+        end
+      end
+      
+      def basename_no_ext
+        self.basename.to_s.split(".")[0..-2].join(".").fwf_filepath
+      end
+      
+      def without_ext
+        self.gsub(/\.#{self.ext}$/, '')
+      end
+      
+      def ext
+        self.basename.to_s.split(".").last || ""
+      end
+      
+      def relative_to( ancestor_dir )
+        depth = ancestor_dir.to_s.split(File::SEPARATOR).length
+        relative_path = self.to_s.split(File::SEPARATOR)
+        relative_path[(depth)..-1].join(File::SEPARATOR).fwf_filepath
+      end
+      
+      def gsub( *args )
+        self.to_s.gsub(*args).fwf_filepath
+      end
+      
+      def gsub!( *args )
+        new_str = self.to_s.gsub(*args)
+        self.instance_variable_set(:@path, new_str)
+      end
+      
+      def fwf_filepath
+        self
+      end
+    end
+  end
+end

data/lib/utils/html_translator.rb

@@ -0,0 +1,99 @@
+module EpubForge
+  module Utils
+    # An individual translator, which receives a filename, determines if it's up to the job
+    # then returns the resulting HTML translation.
+    class HtmlTranslator
+      GROUP_NAMES = [:preferred, :user, :default, :fallback]
+    
+      def initialize
+        group( :user )
+        opts( "" )
+      end
+    
+      def name( n = nil )
+        @name = n if n
+        @name
+      end
+    
+      def group( g = nil )
+        if g
+          raise "group must be one of the following symbols: #{GROUP_NAMES.inspect}" unless GROUP_NAMES.include?(g)
+          @group = g 
+        end
+      
+        @group
+      end
+    
+      def executable executable_name = nil
+        if executable_name
+          @executable_name = Htmlizer.instance.location( executable_name ) || `which #{executable_name}`.strip
+        end
+        @executable_name || ""
+      end
+    
+      def format f = nil
+        @format = f if f
+        @format
+      end
+    
+      def cmd c = nil
+        @cmd = c if c
+        @cmd
+      end
+    
+      def custom_proc( p = nil, &block )
+        if block_given?
+          @custom_proc = block
+        else
+          @custom_proc = c if c
+        end
+      
+        @custom_proc
+      end
+    
+      def opts o = nil
+        @opts = o if o
+        @opts
+      end
+    
+      def installed?
+        executable.length > 0
+      end
+    
+      def handles_format?( f )
+        @format == determine_file_format( f ) || @format == :unknown
+      end
+    
+      def can_do_job?( f )
+        installed? && handles_format?( f )
+      end
+    
+      # opts allows you to override the normal command line arguments
+      # Maybe a description of the job's requirements should be more
+      # elaborate than just a filename.  OTOH, simple can have its advantages.
+      def translate( filename, opts = "" )
+        return false unless can_do_job?( filename )
+      
+        result = "<!-- generated from #{@format} by htmlizer #{@name} -->\n\n" 
+        if @custom_proc
+          result += @custom_proc.call( filename, *opts )
+        elsif @cmd
+          exec_string = cmd.gsub( /\{\{f\}\}/, filename.to_s )
+          opts = @opts if opts.epf_blank?
+          exec_string.gsub!( /\{\{o\}\}/, opts )
+          exec_string.gsub!( /\{\{x\}\}/, executable )
+        
+          result += `#{exec_string}`
+        else
+          return false
+        end
+      
+        result
+      end
+    
+      def determine_file_format( file )
+        file.fwf_filepath.ext.to_sym
+      end
+    end
+  end
+end

data/lib/utils/html_translator_queue.rb

@@ -0,0 +1,70 @@
+module EpubForge
+  module Utils
+    # A priority stack (like a priority queue, but FILO) with a simple job: 
+    # keep track of the translators (by name and by group), and return them
+    # to the object user in the order they should be tried.
+    class HtmlTranslatorQueue
+      GROUP_NAMES = HtmlTranslator::GROUP_NAMES
+      
+      
+      def initialize
+        @translators = {}
+        @all_translators = []
+        @translators_named = {}
+        for name in GROUP_NAMES
+          @translators[name] = []
+        end
+      end
+      
+      # def translators_handling_format( requested_format )
+      #   htmlizers = GROUP_NAMES.map{ |group|
+      #     (@translator_queue.keys - [:all, :named]).map do |format|
+      #       htmlizers = @translator_queue[format][group]
+      #       htmlizers ? htmlizers.select{|html| html.handles_format?(requested_format) } : []
+      #     end
+      #   }
+      #   
+      #   htmlizers.flatten
+      # end
+      
+      # last installed, first yielded (within a given group)
+      # 
+      # Returns them in priority order, user-defined ones first.
+      # At the moment, it is up to individual translators to accept or
+      # reject the translation job based on the file format (by extension, which is lame).
+      def each( &block )
+        ordered_translators = []
+        for group in GROUP_NAMES.map{|g| @translators[g].reverse }
+          ordered_translators += group
+        end
+        
+        if block_given?
+          for translator in ordered_translators
+            yield translator
+          end
+        else
+          ordered_translators.to_enum
+        end
+      end
+      
+      def length
+        @all_translators.length
+      end
+      
+      def categorize( htmlizer )
+        unless GROUP_NAMES.include?( htmlizer.group )
+          puts "No group specified for htmlizer #{htmlizer}.  Group must be one of the following symbols: #{GROUP_NAMES.map(&:inspect).inspect}"
+          return false 
+        end
+        
+        @all_translators << htmlizer
+        @translators_named[htmlizer.name] = htmlizer if htmlizer.name
+        @translators[htmlizer.group] << htmlizer
+      end
+      
+      def named( sym )
+        @translators_named[sym]
+      end
+    end
+  end
+end

data/lib/utils/htmlizer.rb

@@ -0,0 +1,92 @@
+module EpubForge
+  module Utils
+    
+    # Htmlizer coordinates the discovery, selection, and running of HtmlTranslators.
+    # It can be handed basically any supported filetype (markdown, textile, txt), and 
+    # hand back an HTML translation of the file.
+    class Htmlizer
+      include Singleton
+
+      def setup_once
+        return false if @already_set_up 
+        @already_set_up = true
+        @exec_location = {}
+        
+        @translator_queue = HtmlTranslatorQueue.new
+        
+        add_htmlizers( EpubForge.root( 'config', 'htmlizers.rb' ) )
+        add_htmlizers( EpubForge::USER_SETTINGS.join( 'htmlizers.rb' ) )
+        
+        @already_set_up
+      end
+            
+      public
+      def location( name, path = nil )
+        @exec_location[name] = path if path
+        @exec_location[name]
+      end
+
+      # Commenting out for the moment.  Philosophically, maybe it shouldn't provide access to individual translators.
+      # def translators_named( name )
+      #   @translator_queue[:named][name]
+      # end
+
+      
+      def self.define( &block )
+        htmlizer = HtmlTranslator.new
+        yield htmlizer
+        self.instance.categorize( htmlizer )
+      end
+      
+      def categorize( htmlizer )
+        @translator_queue.categorize( htmlizer )
+      end
+      
+      def add_htmlizers( htmlizers_file )
+        if htmlizers_file.exist?
+          begin
+            require htmlizers_file.to_s
+          rescue Exception => e
+            puts e.message
+            puts e.backtrace.map{|line| "\t#{line}" }
+            puts "Failed to load htmlizers from project file #{htmlizers_file} Soldiering onward."
+          end
+        end
+      end
+
+      
+      # available options
+      # :htmlizer => the sym for the requested htmlizer.  
+      # :opts     => a string representing options to execute cmd with
+      def translate( filename, opts = {} )
+        translator  = opts[:translator]
+        translator  = @translator_queue.named( translator ) if translator.is_a?( Symbol )
+        opts      = opts[:opts] || ""
+        
+        if translator
+          if result = translator.translate( filename, {opts: opts } )
+            return result
+          else
+            puts "Named Htmlizer #{htmlizer} did not return html. Falling back on other htmlizers"
+          end
+        end
+
+        for translator in @translator_queue
+          if result = translator.translate( filename, opts )
+            return result
+          end
+        end
+        
+        "<!-- COULD NOT FIND HTMLIZER FOR #{filename} -->"
+      end
+      
+      def self.format_from_filename( filename )
+        ext = filename.fwf_filepath.extname.gsub(/^\./, "")
+        ext.epf_blank? ? :unknown : ext.to_sym
+      end
+    end
+    
+    Htmlizer.instance.setup_once
+  end
+end
+