epubforge 0.0.5

data/config/actions/notes_to_kindle.rb

@@ -0,0 +1,17 @@
+module EpubForge
+  module Action
+    class NotesToKindle < Kindle
+      description "Create a .mobi book from the notes and try to push it to your Kindle"
+      keywords    :n2k
+      usage       "#{$PROGRAM_NAME} n2k <project_directory>"
+  
+      def do( project, args )
+        @project = project
+        @src_epub = @project.filename_for_epub_notes.fwf_filepath
+        @dst_mobi = @project.filename_for_mobi_notes.fwf_filepath
+
+        mobify
+      end
+    end
+  end
+end

data/config/actions/word_count.rb

@@ -0,0 +1,126 @@
+require 'time'  # for Time.parse
+
+module EpubForge
+  module Action
+    class WordCount < ThorAction
+      WORD_COUNT_FILE = "wordcount"
+      
+      description "Gives approximate word counts for book chapters and notes."
+      keywords    :wc, :count
+      usage       "#{$PROGRAM_NAME} count <project_directory>"
+      
+      desc( "do:wc", "Countify words.")
+      def do( project, *args )
+        @project = project
+        @report  = { "Notes" => wc_one_folder( @project.notes_dir ),
+                     "Book"  => wc_one_folder( @project.book_dir  ) }
+
+        load_word_count_history
+        calculate_todays_word_count
+        append_word_count_history( @report )
+        print_report
+        
+        say_all_is_well "Done"
+        @report
+      end
+      
+      protected
+      def wc_one_folder( foldername )
+        foldername.glob( ext: EpubForge::Epub::PAGE_FILE_EXTENSIONS ).inject(0) do |count, file|
+          count += wc_one_file( file )
+        end
+      end
+      
+      # I assume the wc executable is more accurate,
+      # and I don't know which is faster.
+      def wc_one_file( filename )
+        if wc_installed?
+          result = `#{wc_installed?.to_s.strip} -w #{filename}`
+          $?.success? ? result.to_i : 0
+        else
+          filename.read.split.length
+        end
+      end
+      
+      def load_word_count_history
+        @wc_yaml = @project.settings_folder( WORD_COUNT_FILE )
+        @wc_yaml.touch
+        
+        if @wc_yaml.empty?
+          # pretend that you wrote everything in the last six hours.
+          append_word_count_history( {"Notes" => 0, "Book" => 0}, beginning_of_day )
+        end
+        
+        @history = YAML.load( @wc_yaml.read )
+      end
+      
+      def beginning_of_day
+        @beginning_of_day ||= Time.parse( now.strftime("%Y-%m-%d") )
+        @beginning_of_day
+      end
+      
+      def now
+        @now ||= Time.now
+        @now
+      end
+      
+      def append_word_count_history( report, timestamp = now )
+        unless duplicates_previous_history_item( report )
+          @wc_yaml.append do |f|
+            f.write "- #{timestamp}:\n"
+            f.write "    Notes: #{report["Notes"]}\n"
+            f.write "    Book:  #{report["Book"]}\n\n"
+          end
+        end
+      end
+      
+      def duplicates_previous_history_item( report )
+        last = @history.last
+        prior_report = last.values.last
+        time_of_history_item( last ) > beginning_of_day && 
+          prior_report["Notes"] == report["Notes"] && 
+          prior_report["Book"] == report["Book"]
+      end
+      
+      # Works under the ginormous assumption that the last word count recorded for the previous
+      # day was actually the final count, and every word written since then was written for the
+      # current day.  When running for the first time, assumes all prior work was completed the
+      # previous day, and falsifies a history to match that assumption.
+      def calculate_todays_word_count
+        prior_day = @history.reverse.find do |history_item|
+          time_of_history_item( history_item ) <= beginning_of_day
+        end
+        
+        # This should never be nil, but...
+        prior_day = prior_day.nil? ? { "Book" => 0, "Notes" => 0 } : prior_day.values.first
+        
+        @report["Today"] = @report["Notes"] + @report["Book"] - prior_day["Notes"] - prior_day["Book"]
+      end
+      
+      def time_of_history_item( item )
+        t = item.keys.first
+        t = case( t )
+        when Time
+          t
+        when String
+          Time.parse( t )
+        else
+          raise "I have no idea what time it is."
+        end
+      end
+      
+      def wc_installed?
+        executable_installed?( "wc" )
+      end
+      
+      def print_report
+        say "", BLUE
+        say "Wordcount", BLUE
+        say "---------", BLUE
+        say "Notes: #{@report["Notes"]}", BLUE
+        say "Book:  #{@report["Book"]}", BLUE
+        say "Today: #{@report["Today"]}", BLUE
+      end
+    end
+  end
+end

data/config/actions/wrap_scene_notes_in_hidden_div.rb

@@ -0,0 +1,118 @@
+module EpubForge
+  module Action
+    class WrapSceneNotesInHiddenDiv < ThorAction
+      description "Assumes scenes are in book/scene-XXXX.markdown, and that the scene description is above the first horizontal row (a.k.a. ***** in Markdown)."
+      keywords    :wrap_scene_notes
+      usage       "#{$PROGRAM_NAME} wrap_scene_notes<project_directory (optional if current directory)>\n\tfollow with 'undo' to reverse transformation."
+      
+      START_SCENE = 0
+      IN_SCENE    = 1
+      IN_STORY    = 2
+      ABORTING    = 3
+      
+      START_OF_SCENE_MARKER = "<!-- EPUBFORGE::SCENE_DESCRIPTION -->\n"
+      END_OF_SCENE_MARKER = "<!-- /EPUBFORGE::SCENE_DESCRIPTION -->\n"
+      
+      desc( "do:wrap_scene_notes", "Wrap scene notes (obsolete. Do not use.)")
+      def do( project, *args )
+        @project = project
+        
+        if args.first == "undo"
+          unwrap_files  
+        else
+          wrap_files
+        end
+      end
+      
+      protected
+      def wrap_files
+        transform_each_scene do |ft|
+          for line in ft.readlines
+            case @mode
+            when START_SCENE
+              if line =~ /epubforge_scene_description/
+                puts "scene description is already wrapped. skipping..."
+                @mode = ABORTING
+                break
+              end
+              
+              ft << START_OF_SCENE_MARKER
+              ft << line
+              @mode = IN_SCENE
+            when IN_SCENE
+              if line =~ /^\*{3,}\s*$/    # looking for '******'
+                ft << END_OF_SCENE_MARKER
+                @mode = IN_STORY
+              end
+              ft << line
+            when IN_STORY
+              ft << line
+            end
+          end
+          
+          # what if you never find the end?
+          if @mode == IN_SCENE
+            ft << END_OF_SCENE_MARKER
+          end
+        end
+      end
+    
+      def unwrap_files
+        transform_each_scene do |ft|
+          for line in ft.readlines
+            # puts "---------------------------- #{ft.original_filename} - #{ft.finished?} -----------------------------------"
+            #             puts "#{@mode} : #{line}"
+            #             puts File.size?(ft.transformed_filename)
+            #             puts ""
+            
+            case @mode
+            when START_SCENE
+              if line =~ /#{START_OF_SCENE_MARKER}/
+                @mode = IN_SCENE
+              else
+                ft << line
+              end
+            when IN_SCENE
+              if line =~ /#{END_OF_SCENE_MARKER}/
+                @mode = IN_STORY
+              else
+                ft << line
+              end
+            when IN_STORY
+              ft << line
+            end
+          end
+        end
+      end
+      
+      def transform_each_scene &block
+        @transformed_files = []   # save output until the end, then mv them all 
+                                  # when you're sure the process was successful
+        
+        each_scene do |scene|
+          ft = FileTransformer.new( scene )
+          @transformed_files << ft
+          @mode = START_SCENE
+          
+          yield ft
+        end
+        
+        if ask( "Finalize?" ) == "Y"
+          @transformed_files.each do |t|
+            t.finalize
+          end
+        else
+          @transformed_files.each do |t|
+            t.abort
+          end
+        end
+      end
+      
+      def each_scene(&block)
+        for scene in Dir["#{@project.book_dir}/scene-????.markdown"].entries
+          yield scene
+        end
+      end
+    end
+  end
+end

data/config/htmlizers.rb

@@ -0,0 +1,62 @@
+EpubForge::Utils::Htmlizer.define do |html|
+  html.format     :markdown
+  html.group      :default                   # the default is :user, so user-defined ones don't have to set it
+  html.executable "multimarkdown"
+  html.cmd        "{{x}} {{o}} {{f}}"
+  # html.opts       ""                         # the default
+end
+
+EpubForge::Utils::Htmlizer.define do |html|
+  html.format     :markdown
+  html.group      :default
+  html.executable "pandoc"
+  html.cmd        "{{x}} {{o}} {{f}}"
+  html.opts       "--from=markdown --to=html"
+end
+
+EpubForge::Utils::Htmlizer.define do |html|
+  html.format     :textile
+  html.group      :default
+  html.executable "pandoc"
+  html.cmd        "{{x}} {{o}} {{f}}"
+  html.opts       "--from=textile --to=html"
+end
+
+
+# Emergency backups
+EpubForge::Utils::Htmlizer.define do |html|
+  html.format     :markdown
+  html.group      :fallback
+  html.executable "false"
+  html.cmd        "echo \"<pre>\" && cat {{f}} && echo \"</pre>\""
+end
+
+EpubForge::Utils::Htmlizer.define do |html|
+  html.format     :textile
+  html.group      :fallback
+  html.executable "false"
+  html.cmd        "echo \"<pre>\" && cat {{f}} && echo \"</pre>\""
+end
+
+EpubForge::Utils::Htmlizer.define do |html|
+  html.format     :txt
+  html.group      :fallback
+  html.executable "false"
+  html.cmd        "echo \"<pre>\" && cat {{f}} && echo \"</pre>\""
+end
+
+# Would be nice to detect and strip out the outer tags
+# leaving only the content.
+EpubForge::Utils::Htmlizer.define do |html|
+  html.format     :html
+  html.group      :fallback
+  html.executable "false"
+  html.cmd        "cat {{f}}"
+end
+
+EpubForge::Utils::Htmlizer.define do |html|
+  html.format     :unknown
+  html.group      :fallback
+  html.executable "false"
+  html.cmd        "echo \"<pre>\" && cat {{f}} && echo \"</pre>\""
+end

data/lib/action/actions_lookup.rb

@@ -0,0 +1,41 @@
+module EpubForge
+  module Action
+    class ActionsLookup
+      attr_accessor :actions, :actions_directories, :keywords
+
+      def initialize
+        @keywords = {}
+        @actions = []
+        @actions_directories = []
+      end
+
+      def add_actions( *args )
+        Utils::ActionLoader.require_me( *args )
+
+        new_actions = Utils::ActionLoader.loaded_classes - @actions
+        @actions += new_actions
+        new_directories = Utils::ActionLoader.loaded_directories - @actions_directories
+        @actions_directories += new_directories
+
+        for action in new_actions
+          for keyword in action.keywords
+            @keywords[keyword] = action
+          end
+        end
+      end
+
+      # Find all the actions with keywords that start with the given string.
+      # If this results in more than one action being found, the proper
+      # response is to panic and flail arms.
+      def keyword_to_action( keyword )
+        exact_match = @keywords.keys.select{ |k| k == keyword }
+
+        return [@keywords[exact_match.first]] if exact_match.length == 1
+
+        # if no exact match can be found, find a partial match, at the beginning
+        # of the keywords.
+        @keywords.keys.select{ |k| k.match(/^#{keyword}/) }.map{ |k| @keywords[k] }.uniq
+      end
+    end
+  end
+end

data/lib/action/cli_command.rb

@@ -0,0 +1,72 @@
+module EpubForge
+  module Action
+    class CliCommand
+      # undo is an action that would be expected to reverse the consequences of this
+      # action.  You can do without it if the action can't fail, if it has no real
+      # consequences, or if a prior action, when undone, will wipe out those consequences.
+      # For example, if an earlier command created the directory that the current command
+      # is writing a file to, the earlier command would be expected to delete the directory.
+      def initialize( command, undo = nil, opts = {} )
+        @command = command
+        @undo = undo
+        @opts = opts
+        @remote = opts[:remote]   # Is this going to be executed here, or on a different server?  Usually in the form "username@host"
+        @verbose = opts[:verbose]
+        @local_dir = opts[:local_dir]     # the local directory to cd into before executing the command
+        @remote_dir = opts[:remote_dir]   # the remote directory to cd into before executing the command
+      end
+      
+      def execute( cmd = :cmd )
+        @remote ? remote_exec( cmd ) : local_exec( cmd )
+      end
+      
+      def undo
+        execute( :undo )
+      end
+      
+      protected
+      def local_exec( cmd )
+        cmd = (cmd == :undo ? @undo : @command)
+        return pseudo_success if cmd.epf_blank?
+
+        execute_locally = @local_dir ? "cd #{@local_dir} && " : ""
+        
+        @msg = "attempting to run locally:  #{cmd}"
+        `#{execute_locally}#{cmd}`
+        print_result
+        $?  
+      end
+      
+      def remote_exec( cmd )
+        cmd = (cmd == :undo ? @undo : @command)
+        return pseudo_success if cmd.epf_blank?
+
+        execute_remotely = (@remote_dir ? "cd #{@remote_dir} && " : "") + cmd
+
+        @msg = "attempting to run remotely (#{@remote}):  #{execute_remotely}"
+        `ssh #{@remote} "#{execute_remotely}"`
+        print_result
+        $?
+      end
+      
+      def print_result
+        puts "#{$?.success? ? 'SUCCESS' : 'FAIL'}: #{@msg}" if @verbose
+      end
+      
+      def pseudo_success
+        unless @pseudo_success_object
+          @pseudo_success_object = Object.new
+          m = Module.new do
+            def success?
+              true
+            end
+          end
+        
+          @pseudo_success_object.extend( m )
+        end
+        
+        @pseudo_success_object
+      end
+    end
+  end
+end

data/lib/action/cli_sequence.rb

@@ -0,0 +1,55 @@
+module EpubForge
+  module Action
+    class CliSequence
+      def initialize
+        @defaults = {}
+        @local_dir
+        @commands = []
+        @completed = []
+      end
+      
+      def default( k, v )
+        if k == :remote
+          @remote = v
+        else
+          @defaults[k] = v
+        end
+      end
+      
+      def add_local_command( command, undo = nil, opts = {} )
+        add_command( command, undo, opts )
+      end
+      
+      def add_remote_command( command, undo = nil, opts = {} )
+        opts[:remote] ||= @remote         # the default username/host can be overridden by sending a different opts[:remote]
+        add_command( command, undo, opts)
+      end
+      
+      def execute
+        @failed = false
+        while (cmd = @commands.shift) && (@failed == false)
+          @failed = true unless cmd.execute.success?
+          @completed.push( cmd )
+        end
+        
+        undo unless @failed == false
+        !@failed
+      end
+      
+      def undo
+        while cmd = @completed.pop
+          result = cmd.undo
+          @commands.unshift( cmd )
+        end
+      end
+      
+      def add_command( command, undo = "", opts = {} )
+        for default, setting in @defaults
+          opts[default] ||= setting
+        end
+        
+        @commands.push( CliCommand.new(command, undo, opts) )
+      end
+    end
+  end
+end

data/lib/action/file_transformer.rb

@@ -0,0 +1,59 @@
+module EpubForge
+  module Action
+    class FileTransformer
+      attr_reader :original_filename, :transformed_filename
+      def initialize( file )
+        @original_filename = file
+        @transformed_filename = "#{@original_filename}.epubforge.#{sprintf("%07i", rand(1000000))}.tmp"
+        @out = File.open( @transformed_filename, "w" )
+        @finished = false
+      end
+  
+      def finalize
+        return if finished?
+        @finished = true
+        @out.close
+    
+        FileUtils.mv( @transformed_filename, @original_filename )
+      end
+  
+      def abort
+        return if finished?
+        @finished = true
+        FileUtils.rm( @transformed_filename )
+      end
+  
+      def write( input )
+        return if finished?
+        @out << input
+        @out.flush
+      end
+  
+      def <<( input )
+        write( input )
+      end
+  
+      def read_file
+        File.read( @original_filename )
+      end
+  
+      def readlines( &block )
+        File.readlines( @original_filename ) do |line|
+          yield line
+        end
+      end
+  
+      def old_size
+        File.size?( @original_filename )
+      end
+  
+      def new_size
+        File.size?( @transformed_filename )
+      end
+  
+      def finished?
+        @finished
+      end
+    end
+  end
+end

data/lib/action/run_description.rb

@@ -0,0 +1,24 @@
+module EpubForge
+  module Action
+    class RunDescription
+      attr_accessor :args
+      attr_accessor :project
+      attr_accessor :keyword
+      attr_accessor :klass
+      attr_accessor :errors
+      
+      def initialize
+        @args = nil
+        @project = nil
+        @keyword = nil
+        @klass = nil
+        @errors = []
+      end
+      
+      def runnable?
+        @errors.epf_blank?
+      end
+    end
+  end
+end
+    

data/lib/action/runner.rb

@@ -0,0 +1,122 @@
+# Another trivial change
+
+module EpubForge
+  module Action
+    class Runner
+      attr_accessor :actions_lookup
+      def initialize
+        reset
+      end
+      
+      def reset
+        @args = []
+        @run_description = RunDescription.new
+        @actions_lookup = ActionsLookup.new
+        @actions_lookup.add_actions( EpubForge::ACTIONS_DIR )
+        @actions_lookup.add_actions( EpubForge::USER_ACTIONS_DIR ) if EpubForge::USER_ACTIONS_DIR.directory?
+      end
+            
+      def run
+        if @run_description.runnable?
+          @run_description.klass.new.do( @run_description.project, *(@run_description.args) )
+        else
+          puts "Error(s) trying to complete the requested action:"
+          puts @run_description.errors.join("\n")
+        end
+      end
+      
+      # order:  project_dir(optional), keyword, args
+      # If a project_dir is not given, the current working directory is prepended to the arguments list.
+      # In some cases -- well, really only 'init', this will be in error.  Because the argument given does
+      # not exist yet, it will not recognize the first argument as pointing to a project. 
+      def exec( *args )
+        # remove project from arguments
+        @args = args
+        # first argument is the action's keyword
+        # print help message if no keywords given
+        parse_args
+        
+        # finish setting up run_description
+        @run_description.args = @args
+        
+        run
+      end
+    
+    
+      # The priority for the project directory
+      # 1) explicitly stated directory  --project=/home/andersbr/writ/fic/new_project
+      # 2) the current working directory (if it's an existing project)
+      # 3) the final arg
+      #
+      # At this point, 
+      protected
+      def parse_args
+        @run_description = RunDescription.new
+        @run_description.keyword = @args.shift || "help"
+        
+        existing_project = false
+        project_dir = get_explicit_project_option( @args )
+        
+        # see if the last argument is a project directory
+        unless project_dir || @args.length == 0
+          last_arg = @args.pop
+          unless project_dir = ( Project.is_project_dir?( last_arg ) )
+            @args.push( last_arg )
+          end
+        end
+        
+        # see if current working directory is a project directory
+        unless project_dir 
+          cwd = FunWith::Files::FilePath.cwd
+          if Project.is_project_dir?( cwd )
+            project_dir = cwd
+          end
+        end
+        
+        # At this point, if we're going to find an existing project directory, we'll have found it by now.
+        # Time to load the actions and determine whether the keyword matches an existing action
+        if project_dir && Project.is_project_dir?( project_dir )
+          existing_project = true
+          @run_description.project = Project.new( project_dir )
+          @actions_lookup.add_actions( @run_description.project.settings_folder( "actions" ) )
+          Utils::Htmlizer.instance.add_htmlizers( @run_description.project.settings_folder( "htmlizers.rb" ) )
+        end
+        
+        map_keyword_to_action
+        
+        if !existing_project && @run_description.klass.project_required?
+          @run_description.errors << "Could not find a project directory, but the action #{@run_description.klass} requires one. Current directory is not an epubforge project."
+        end
+      end
+      
+      def map_keyword_to_action
+        actions = actions_lookup.keyword_to_action( @run_description.keyword )
+
+        if actions.length == 1
+          @run_description.klass = actions.first
+        elsif actions.length == 0
+          @run_description.errors << "Unrecognized keyword <#{keyword}>.  Quitting."
+          false
+        else
+          @run_description.errors << "Ambiguous keyword <#{keyword}>.  Did you mean...?\n#{actions.map(&:usage).join('\n')}"
+          false
+        end
+      end
+      
+      def get_explicit_project_option( args )
+        proj_opt_regex = /^--project=/
+        
+        proj_opt = args.find do |arg|
+          arg.is_a?(String) && arg.match( proj_opt_regex )
+        end
+      
+        if proj_opt
+          args.delete( proj_opt )
+          proj_opt.gsub( proj_opt, '' ).fwf_filepath
+        else
+          false
+        end
+      end
+    end
+  end
+end