epubforge 0.0.10 → 0.0.11

data/lib/utils/action_loader.rb

@@ -1,7 +0,0 @@
-module EpubForge
-  module Utils
-    class ActionLoader < ClassLoader
-      namespace( "EpubForge::Action" )
-    end
-  end
-end

data/lib/utils/class_loader.rb

@@ -1,102 +0,0 @@
-module EpubForge
-  module Utils
-    # filepath string with metadata, representing a class 
-    # file that can be loaded.
-    class ClassLoader < FunWith::Files::FilePath
-      def self.loaded_classes
-        @loaded_classes ||= []
-      end
-      
-      def self.loaded_directories
-        @loaded_directories ||= []
-      end
-      
-      def self.namespace( nsp = nil )
-        @namespace = nsp unless nsp.nil?
-        @namespace
-      end
-  
-      def class_name
-        unless @class_name
-          base = self.basename.to_s.split(".")[0].epf_camelize
-          @class_name = "#{self.class.namespace}::#{base}"
-        end
-        @class_name
-      end
-  
-      # Returns true if an error was raised when trying to require the file,
-      # or if the expected class is not loaded after the file was required.
-      # Proper naming is very important here.
-      def require_me
-        begin
-          require self.to_s
-        rescue NameError => e
-          puts "Error encounterd while trying to load #{self.class_name} from #{self}"
-          puts e.message
-          puts e.backtrace.map{|line| "\t#{line}" }
-          return false
-        end
-        
-        return self.class_loaded?
-      end
-  
-      def class_loaded?
-        begin
-          self.to_class
-          return true
-        rescue NameError     # There's gotta be another way I should be doing this.
-          return false
-        end
-      end
-  
-      def to_class
-        return @klass unless @klass.nil?
-        @klass = Utils::Misc.constantize( self.class_name )
-      end
-      
-      def self.require_me( *loadables )
-        @loaded_classes ||= []
-        @loaded_directories ||= []
-        
-        for loadable in loadables
-          loadable = self.new( loadable )
-          
-          if loadable.file?
-            if loadable.require_me
-              @loaded_classes << loadable.to_class
-            else
-              puts "Warning: Failed to load #{loadable.class_name} from file #{loadable}"
-            end
-          elsif loadable.directory?
-            @loaded_directories << loadable
-            loadable.glob( "**", "*.rb" ).each do |entry|
-              self.require_me( entry )
-            end
-          else
-            puts "Warning: Could not find file #{loadable} to load classes from."
-          end
-        end
-      end
-      
-      # just loading all the files is simpler, and probably little harm from reloading.  Plus, I want
-      # to be able to split up existing ThorClasses across multiple files.
-      def self.load_me( *loadables )
-        silence_warnings do
-          for loadable in loadables
-            loadable = loadable.fwf_filepath
-          
-            if loadable.file?
-              load( loadable )
-            elsif loadable.directory?
-              for entry in loadable.glob( :ext => "rb", :recursive => true )
-                load( entry )
-              end
-            else
-              puts "Warning: No idea what I'm trying to load (#{loadable}:#{loadable.class})"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/utils/directory_builder.rb

@@ -1,181 +0,0 @@
-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/file_path.rb

@@ -1,152 +0,0 @@
-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_path_from( 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

@@ -1,100 +0,0 @@
-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 =  ""
-        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 += "\n\n<!-- generated from #{@format} by htmlizer #{@name} -->\n" 
-        result
-      end
-    
-      def determine_file_format( file )
-        file.fwf_filepath.ext.to_sym
-      end
-    end
-  end
-end