epubforge 0.0.10 → 0.0.11

data/lib/epubforge/builder/html.rb

@@ -0,0 +1,22 @@
+module EpubForge
+  module Builder
+    class Html < Builder
+      def build
+        @html_content = ""
+        
+        @sections.each do |section|
+          @html_content << section.html
+          @html_content << "\n\n"         # couldn't hurt?
+        end
+      end
+      
+      def package( html_filename )
+        html_filename.write( wrap_page( @html_content ) )
+      end
+      
+      def clean
+        # do nothing
+      end
+    end
+  end
+end

data/lib/epubforge/builder/packager.rb

@@ -0,0 +1,16 @@
+# module EpubForge
+#   module Epub
+#     class Packager
+#       def initialize( src_dir, dst_filename )
+#         @src_dir = src_dir
+#         @dst_filename = dst_filename
+#       end
+#       
+#       def package
+#         @dst_filename = @dst_filename.expand
+#         FileUtils.rm( @dst_filename ) if @dst_filename.exist?
+#         `cd #{@src_dir} && zip -Xr #{@dst_filename.to_s.epf_backhashed_filename} mimetype META-INF OEBPS`
+#       end
+#     end
+#   end
+# end

data/lib/epubforge/core_extensions/array.rb

@@ -0,0 +1,2 @@
+class Array
+end

data/lib/epubforge/core_extensions/nil_class.rb

@@ -0,0 +1,2 @@
+class NilClass
+end

data/lib/epubforge/core_extensions/object.rb

@@ -0,0 +1,24 @@
+# class Object
+#   def umethods( regex = /.*/ )
+#     (self.methods.sort - Object.new.methods).grep( regex )
+#   end
+#   
+#   def get_and_set( *method_names )
+#     for name in method_names
+#       if self.is_a?(Class) || self.is_a?(Module)
+#         eval "define_method( :#{name} ) do |*args|
+#                 self.instance_variable_set( :@#{name}, args.first ) if args.length == 1
+#                 self.instance_variable_get( :@#{name} )
+#               end"
+#       else
+#         m = Module.new
+#         m.get_and_set( *method_names )
+#         self.extend( m )
+#       end
+#       # define_method( name ) do |*args|
+#       #   self.instance_variable_set( :"@#{__method__}", args.first ) if args.length == 1
+#       #   self.instance_variable_get( :"@#{__method__}" )
+#       # end
+#     end
+#   end
+# end

data/lib/{core_extensions → epubforge/core_extensions}/string.rb

@@ -1,8 +1,4 @@
 class String
-  def epf_blank?
-    self.strip.length == 0  
-  end
-  
   def epf_camelize
     gsub(/(?:^|_)(.)/) { $1.upcase }
   end
@@ -28,7 +24,7 @@ class String
     nocaps = %w(a and at be but in is nor of or so teh the to with)
     upcase = %w(Ii Ii: Iii M.d.)       # TODO:  ick
 
-    words = self.downcase.gsub(/\u00a0/, ' ').split(/(\s|\n)+/).map(&:strip).delete_if(&:epf_blank?)
+    words = self.downcase.gsub(/\u00a0/, ' ').split(/(\s|\n)+/).map(&:strip).delete_if(&:fwf_blank?)
     first_word = true
 
     for word in words

data/lib/{custom_helpers.rb → epubforge/custom_helpers.rb}

@@ -63,4 +63,3 @@ module EpubForge
   end
 end
 
-EpubForge.extend( EpubForge::CustomHelpers )

data/lib/{project → epubforge/project}/project.rb

@@ -4,29 +4,26 @@ module EpubForge
     CONFIG_FILE_NAME = "config.rb"
     PROJECT_ACTIONS_DIRECTORY = "actions"
 
-    attr_reader :target_dir, :config_file, :config, :book_dir,
-                :notes_dir, :project_basename, :filename_for_epub_book, 
-                :filename_for_mobi_book, :filename_for_epub_notes, 
-                :filename_for_mobi_notes, :actions_dir
+    attr_reader :root_dir, :config_file, :config, :book_dir,
+                :notes_dir, :project_basename, :filename_for_book, 
+                :filename_for_notes, :actions_dir
                 
-    def initialize( target_dir )
-      @target_dir = FunWith::Files::FilePath.new( target_dir ).expand
+    def initialize( root_dir )
+      @root_dir = FunWith::Files::FilePath.new( root_dir ).expand
       
       load_configuration
 
-      @notes_dir = config.notes_dir || @target_dir.join( "notes" )
-      @book_dir  = config.book_dir  || @target_dir.join( "book" )
+      @notes_dir = config.notes_dir || @root_dir.join( "notes" )
+      @book_dir  = config.book_dir  || @root_dir.join( "book" )
     
       @project_basename = default_project_basename
-      @filename_for_epub_book = @target_dir.join( "#{default_project_basename}.epub" )
-      @filename_for_mobi_book = @target_dir.join( "#{default_project_basename}.mobi" )
-      @filename_for_epub_notes = @target_dir.join( "#{default_project_basename}.notes.epub" )
-      @filename_for_mobi_notes = @target_dir.join( "#{default_project_basename}.notes.mobi" )
+      @filename_for_book = @root_dir.join( "#{default_project_basename}" )
+      @filename_for_notes = @root_dir.join( "#{default_project_basename}.notes" )
     end 
     
     # shorthand string that 'names' the project, like the_vampire_of_the_leeky_hills.  Variable-ish, used within filenames
     def default_project_basename
-      config.filename || @target_dir.basename.to_s.gsub( /\.epubforge$/ , '' )
+      config.filename || @root_dir.basename.to_s.gsub( /\.epubforge$/ , '' )
     end
 
     # TODO: should test be more definitive?
@@ -38,11 +35,11 @@ module EpubForge
     end
     
     def project_exists?
-      @target_dir.exist? && config_file.exist?
+      @root_dir.exist? && config_file.exist?
     end
     
     def settings_folder(*args)
-      @settings_folder ||= @target_dir.join( SETTINGS_FOLDER )
+      @settings_folder ||= @root_dir.join( SETTINGS_FOLDER )
       @settings_folder.join( *args )
     end
     
@@ -71,11 +68,20 @@ module EpubForge
         raise "Project#pages cannot take #{order.class} as an ordering object."
       end
       
-      orderer.reorder( @book_dir.glob( ext: EpubForge::Epub::PAGE_FILE_EXTENSIONS ) )
+      orderer.reorder( @book_dir.glob( ext: EpubForge::Builder::PAGE_FILE_EXTENSIONS ) )
     end
     
     def load_configuration
-      self.install_fwc_config_from_file( config_file )
+      puts "NO CONFIGURATION FILE DETECTED" unless config_file.file?
+      
+      begin
+        self.install_fwc_config_from_file( config_file )
+        true
+      rescue SyntaxError => e
+        puts "Syntax Error in project configuration file #{config_file}. Quitting.".paint(:red)
+        puts e.message
+        exit(-1)
+      end
     end
   end
 end

data/lib/epubforge/utils/action_loader.rb

@@ -0,0 +1,8 @@
+# module EpubForge
+#   module Action
+#     class Registry
+#       include FunWith::Patterns::Loader
+#       alias :loader_pattern_registry_key :keyword
+#     end
+#   end
+# end

data/lib/epubforge/utils/class_loader.rb

@@ -0,0 +1,102 @@
+# 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/epubforge/utils/converter.rb

@@ -0,0 +1,94 @@
+module EpubForge
+  module Utils
+    
+    # TODO: Starting to get the feeling that an HtmlTranslator is just a subtype of Converter.
+    class Converter
+      get_and_set :command, :executable, :help, :input_format, :label, :output_format
+
+      include FunWith::Patterns::Loader
+      loader_pattern_configure( :bracketwise_lookup, 
+                                :warn_on_key_change, 
+                                { :key => :label, :verbose => true } )
+                                
+      def self.all
+        self.loader_pattern_registry
+      end
+      
+      def self.converts( input_format, output_format = :any )
+        self.all.select{ |k,v|
+          if v.input_format == input_format
+            output_format == :any || v.output_format == output_format
+          else
+            false
+          end
+        }.values
+      end
+      
+      def initialize( &block )
+        instance_exec( &block ) 
+        @command ||= "{{x}} {{o}} '{{src}}' '{{dst}}'"   # default
+        self
+      end
+      
+      # def label( lbl = nil )
+      #   @label = lbl unless lbl.nil?
+      #   @label
+      # end
+      # 
+      # def from( fmt = nil)
+      #   @src_format = fmt unless fmt.nil?
+      #   @src_format
+      # end
+      # 
+      # def to( fmt = nil)
+      #   @dst_format = fmt unless fmt.nil?
+      #   @dst_format
+      # end
+      # 
+      # def executable( executable_name = nil )
+      #   @executable_name = executable_name unless executable_name.nil?
+      #   @executable_name
+      # end
+      
+      def is_executable_installed?
+        @executable && `which #{executable}`.strip.fwf_blank? == false
+      end
+        #     
+        # def command( cmd = nil )
+        #   @command = cmd unless cmd.nil?
+        #   @command ||= "{{x}} {{opts}} '{{src}}' '{{dst}}'"   # default
+        # end
+        #      
+        
+      # opts {
+      #    :dest => Destination (output) file,
+      #    :command_line_options =>  Arguments to feed to the executable. Just a string, replaces the {{o}} in @command
+      # } 
+      def convert( src, opts = {} )
+        src = src.fwf_filepath
+        dst = opts[:dest].is_a?(String) ? opts[:dest].fwf_filepath : opts[:dest]
+
+        if dst.nil? 
+          dst = src.gsub( /#{@input_format}$/, @output_format.to_s )
+        end
+        
+        if is_executable_installed?
+          if src.file?
+            cmd = command.gsub("{{x}}", executable.to_s).gsub("{{o}}", opts[:command_line_options]).gsub("{{src}}", src).gsub("{{dst}}", dst)
+            puts "running command : #{cmd}"
+            
+            
+
+            `#{cmd}`
+            $?.success?
+          else
+            warn( "Source file #{src} does not exist.".paint(:red,:bold))
+            false
+          end
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/epubforge/utils/file_path.rb

@@ -0,0 +1,8 @@
+# Should be obsoleted by FunWith::Files::FilePath
+# Emptying to see if anything breaks.
+module EpubForge
+  module Utils
+    class FilePath < Pathname
+    end
+  end
+end

data/lib/epubforge/utils/html_translator.rb

@@ -0,0 +1,126 @@
+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
+      include HtmlTranslatorQueue
+
+      get_and_set( :name, :opts, :format, :cmd )
+      
+      def self.translate( filename, opts = {} )
+        translator  = opts[:translator]
+        translator  = self.named( translator ) if translator.is_a?( Symbol )
+        opts      = opts[:opts] || ""
+        
+        if translator
+          if result = translator.translate( filename, {opts: opts } )
+            return result
+          else
+            puts "Named HtmlTranslator #{translator} did not return html. Falling back on other html translators"
+          end
+        end
+
+        for translator in HtmlTranslator.each_translator
+          if result = translator.translate( filename, opts )
+            return result
+          end
+        end
+        
+        "<!-- COULD NOT FIND HTML TRANSLATOR FOR FORMAT (#{filename}) -->"
+      end
+
+      # Unneeded?
+      # def self.format_from_filename( filename )
+      #   ext = filename.fwf_filepath.ext
+      #   ext.fwf_blank? ? :unknown : ext.to_sym
+      # end
+      # 
+      
+      
+      
+      def initialize( &block )
+        # set some defaults
+        group( :user )
+        opts( "" )
+        
+        self.instance_exec( &block ) if block_given?
+        self      # explicitly return.  Thought that wasn't necessary, but...
+      end
+    
+      def group( g = nil )
+        if g
+          raise "group must be one of the following symbols: #{HtmlTranslatorQueue::GROUP_NAMES.inspect}" unless HtmlTranslatorQueue::GROUP_NAMES.include?(g)
+          @group = g 
+        end
+      
+        @group
+      end
+    
+      def executable( executable_name = nil )
+        if executable_name
+          @executable_name = HtmlTranslator.location( executable_name ) || `which #{executable_name}`.strip
+        end
+        @executable_name || ""
+      end
+    
+    
+      def custom_proc( *args, &block )
+        if block_given?
+          @custom_proc = block
+        elsif args.first.is_a?(Proc)
+          @custom_proc = args.first
+        end
+      
+        @custom_proc
+      end
+
+      def installed?
+        executable.length > 0
+      end
+    
+      def handles_format?( f )
+        @format == get_file_format( f ) || @format == :unknown
+      end
+    
+      def can_do_job?( f )
+        handles_format?( f ) && ( has_executable_installed? || has_custom_proc? )
+      end
+
+      def has_executable_installed?
+        executable.is_a?(String) && ! executable.fwf_blank?     # 'which will return an empty string if the given executable isn't in the path'
+      end
+      
+      def has_custom_proc?
+        @custom_proc.is_a?( Proc )
+      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.fwf_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 html translator #{@name} -->\n" 
+        result
+      end
+    
+      def get_file_format( file )
+        file.fwf_filepath.ext.to_sym
+      end
+    end
+  end
+end