softcover-nonstop 1.0.beta2

data/lib/softcover/commands/generator.rb

@@ -0,0 +1,140 @@
+require 'erb'
+module Softcover
+  module Commands
+    module Generator
+      include Softcover::Output
+      extend self
+
+      # Generates the default book file tree.
+      def generate_file_tree(name, options = {})
+        @name = name
+        @markdown = !options[:polytex]
+
+        thor = Thor::Shell::Basic.new
+
+        puts "Generating directory: #{name}"
+
+        overwrite_all = false
+
+        FileUtils.mkdir name unless File.exist?(name)
+        Dir.chdir name
+
+        # Create the directories.
+        # There was some trouble with MathJax where it was trying to copy a
+        # file before the directory had been created, so we now create all
+        # the directories first.
+        directories.each do |path|
+          (cp_path = path.dup).slice! template_dir + "/"
+          unless File.exist?(cp_path)
+            puts "Creating #{cp_path}" unless cp_path =~ /MathJax/
+            FileUtils.mkdir cp_path
+          end
+        end
+
+        # Create the files.
+        files.each do |path|
+          next if path =~ /\/.$|\/..$/
+
+          (cp_path = path.dup).slice! template_dir + "/"
+
+          if path =~ /book\.tex/
+            cp_path = "#{name}.tex"
+          elsif path =~ /\.erb/
+            cp_path = File.join(File.dirname(cp_path),
+                                File.basename(path.dup, '.erb'))
+          elsif path =~ /gitignore/
+            cp_path = '.gitignore'
+          end
+
+          display_path = File.join name, cp_path
+
+          if File.exist?(cp_path) && !overwrite_all
+            res = thor.ask "#{display_path} already exists. " \
+                           "Overwrite? (yes,no,all):"
+
+            overwrite = case res
+            when /y|yes/ then true
+            when /n|no/  then false
+            when /a|all/ then
+              overwrite_all = true
+              true
+            end
+
+            next unless overwrite
+          end
+
+          puts "Creating #{cp_path}" unless cp_path =~ /MathJax/
+          if path =~ /\.erb/
+            erb = ERB.new(File.read(path)).result(binding)
+            File.open(cp_path, 'w') { |f| f.write erb }
+          else
+            FileUtils.cp path, cp_path
+          end
+        end
+
+        # Symlink the images directory.
+        Dir.chdir "html"
+        FileUtils.rm_f("images") if File.directory?("images")
+        File.symlink("../images", "images")
+
+        Dir.chdir "../.."
+        book_yml = File.join(Softcover::Directories::CONFIG, 'book.yml')
+        puts "Done. Please update #{book_yml}"
+      end
+
+      def template_dir
+        File.expand_path File.join File.dirname(__FILE__), "..", "template"
+      end
+
+      # Returns a list of all the files and directories used to build the book.
+      def all_files_and_directories
+        files_directories_maybe_markdown
+      end
+
+      # Returns the files and directories based on the input format.
+      def files_directories_maybe_markdown
+        fds = Dir.glob(File.join(template_dir, "**/*"), File::FNM_DOTMATCH)
+        if markdown?
+          # Skip the PolyTeX chapter files, which will be generated later.
+          fds.reject { |e| e =~ /\/chapters\/.*\.tex/ }
+        else
+          # Skip the Markdown files.
+          fds.reject { |e| e =~ /chapters\/.*\.md/ }
+        end
+      end
+
+      # Returns just the directories used for building the book.
+      def directories
+        all_files_and_directories.select { |path| File.directory?(path) }
+      end
+
+      # Returns just the files (not directories) used for building the book.
+      def files
+        all_files_and_directories.reject { |path| File.directory?(path) }
+      end
+
+      def markdown?
+        @markdown
+      end
+
+      def verify!
+        generated_files = Dir.glob("**/*", File::FNM_DOTMATCH).map do |f|
+          File.basename(f)
+        end
+
+        Softcover::Commands::Generator.all_files_and_directories.each do |file|
+          path = if file =~ /book\.tex/
+                   "#{@name}.tex"
+                 elsif file =~ /\.erb/
+                   File.basename(file, '.erb')
+                 elsif file =~ /gitignore/
+                   '.gitignore'
+                 else
+                   File.basename(file)
+                 end
+          raise "missing #{file}" unless generated_files.include?(path)
+        end
+      end
+    end
+  end
+end

data/lib/softcover/commands/opener.rb

@@ -0,0 +1,17 @@
+module Softcover
+  module Commands
+    module Opener
+      extend self
+
+      def open!
+        book.open_in_browser
+      end
+
+      # Returns the book to be opened.
+      def book
+        Softcover::Book.new(origin: Softcover::Utils::source)
+      end
+
+    end
+  end
+end

data/lib/softcover/commands/publisher.rb

@@ -0,0 +1,131 @@
+module Softcover::Commands::Publisher
+  include Softcover::Utils
+  include Softcover::Output
+
+  extend self
+
+  def publish!(options={})
+    return false unless current_book
+
+    if current_book.create_or_update(options)
+      require 'ruby-progressbar'
+      require 'curb'
+      unless options[:quiet] || options[:silent]
+        puts "Uploading #{current_book.uploader.file_count} files " \
+             "(#{as_size current_book.uploader.total_size}):"
+      end
+
+      url = current_book.upload!(options)
+      current_book.process_media_directory "ebooks"
+
+      unless options[:quiet] || options[:silent]
+        puts "Published! #{url}"
+      end
+    else
+      puts "Errors: #{current_book.errors}"
+      return false
+    end
+
+    true
+  rescue Softcover::BookManifest::NotFound => e
+    puts e.message
+    false
+  rescue Softcover::Book::UploadError => e
+    puts e.message
+    false
+  end
+
+  def publish_media!(options={})
+    return false unless current_book
+
+    require 'ruby-progressbar'
+    require 'curb'
+
+    current_book.media_dir = options[:dir] || Softcover::Book::DEFAULT_MEDIA_DIR
+
+    @watch = options[:watch]
+
+    if options[:daemon]
+      pid = fork do
+        run_publish_media(options)
+      end
+
+      puts "Daemonized, pid: #{pid}"
+    else
+      run_publish_media(options)
+    end
+
+    current_book
+  end
+
+  def run_publish_media(options={})
+    if @watch
+      puts "Watching..."
+
+      Signal.trap("TERM") do
+        puts "SIGTERM received."
+        exit_with_message
+      end
+
+      begin
+        loop do
+          process_media(options)
+          sleep 1
+        end
+      rescue Interrupt
+        puts " Interrupt Received."
+        exit_with_message
+      end
+    else
+      process_media(options)
+      exit_with_message
+    end
+  end
+
+  def process_media(options={})
+    current_book.process_media(options)
+  end
+
+  def exit_with_message
+    number = current_book.processed_media.size
+    dir = number == 1 ? "directory" : "directories"
+    puts "Processed #{number} #{dir}"
+  end
+
+  def unpublish!(slug=nil)
+    require "rest_client"
+    require "softcover/client"
+
+    if slug.present?
+      begin
+        res = Softcover::Client.new.destroy_book_by_slug(slug)
+        if res["errors"]
+          puts "Errors: #{res.errors}"
+          return false
+        else
+          puts "Done!"
+          return true
+        end
+      rescue RestClient::ResourceNotFound
+        puts "Book with slug='#{slug}' not found under this account."
+        return false
+      end
+    end
+
+    return false unless current_book
+    if current_book.destroy
+      Softcover::BookConfig.remove
+      puts "Done!"
+      return true
+    else
+      puts "Errors: #{current_book.errors}"
+      return false
+    end
+  rescue RestClient::ResourceNotFound
+    puts "Book with ID=#{current_book.id} not found under this account."
+    false
+  rescue Softcover::BookManifest::NotFound => e
+    puts e.message
+    false
+  end
+end

data/lib/softcover/commands/server.rb

@@ -0,0 +1,66 @@
+require 'listen'
+
+module Softcover::Commands::Server
+  include Softcover::Output
+  include Softcover::Utils
+  attr_accessor :no_listener
+  extend self
+
+  # Listens for changes to the book's source files.
+  def listen_for_changes
+    return if defined?(@no_listener) && @no_listener
+    server_pid = Process.pid
+    filter_regex = /(\.md|\.tex|custom\.sty|custom\.css|Book\.txt|book\.yml)$/
+    @listener = Listen.to('.')
+    @listener.filter(filter_regex)
+
+    @listener.change do |modified|
+      first_modified = modified.try(:first)
+      unless first_modified =~ ignore_regex
+        rebuild first_modified
+        Process.kill("HUP", server_pid)
+      end
+    end
+    @listener.start
+  end
+
+  # Returns a regex for files to be ignored by the listener.
+  def ignore_regex
+    ignores = ['generated_polytex', '\.tmp\.tex']
+    # Ignore <book>.tex, which gets overwritten each time PolyTeXnic runs,
+    # unless there's no Book.txt, which means the author is using raw LaTeX.
+    if File.exist?(Softcover::BookManifest::TXT_PATH)
+      ignores << Regexp.escape(Dir.glob('*.tex').first)
+    end
+    /(#{ignores.join('|')})/
+  end
+
+  def markdown?
+    !Dir.glob(path('chapters/*.md')).empty?
+  end
+
+  def rebuild(modified=nil)
+    printf modified ? "=> #{File.basename modified} changed, rebuilding... " :
+                      'Building...'
+    t = Time.now
+    builder = Softcover::Builders::Html.new
+    builder.build
+    puts "Done. (#{(Time.now - t).round(2)}s)"
+
+  rescue Softcover::BookManifest::NotFound => e
+    puts e.message
+  end
+
+  def start_server(port)
+    require 'softcover/server/app'
+    puts "Running Softcover server on http://localhost:#{port}"
+    Softcover::App.set :port, port
+    Softcover::App.run!
+  end
+
+  def run(port)
+    rebuild
+    listen_for_changes
+    start_server port
+  end
+end

data/lib/softcover/config.rb

@@ -0,0 +1,62 @@
+module Softcover
+  class BaseConfig
+
+    DEFAULTS = {
+      host: 'https://www.softcover.io'
+    }
+
+    PATH = '.'
+
+    class << self
+      def [](key)
+        store.transaction do
+          store[key]
+        end || DEFAULTS[key.to_sym]
+      end
+
+      def []=(key, value)
+        store.transaction do
+          store[key] = value
+        end
+      end
+
+      def read
+        puts `cat #{file_path}`
+      end
+
+      def remove
+        File.delete(file_path) if exists?
+      end
+
+      def exists?
+        File.exists?(file_path)
+      end
+
+      protected
+        def store
+          require 'yaml/store'
+          @store ||= begin
+             YAML::Store.new(file_path)
+          end
+        end
+
+        def file_path
+          File.expand_path(path).tap do |full_path|
+            full_path.gsub!(/$/,"-test") if Softcover::test?
+          end
+        end
+    end
+  end
+
+  class BookConfig < BaseConfig
+    def self.path
+      ".softcover-book"
+    end
+  end
+
+  class Config < BaseConfig
+    def self.path
+      File.exists?(".softcover") ? ".softcover" : "~/.softcover"
+    end
+  end
+end

data/lib/softcover/directories.rb

@@ -0,0 +1,5 @@
+module Softcover::Directories
+  CONFIG = 'config'
+  TMP    = 'tmp'
+  STYLES = 'latex_styles'
+end

data/lib/softcover/formats.rb

@@ -0,0 +1,5 @@
+module Softcover
+  FORMATS = %w{html epub mobi pdf}
+  # mobi calls epub, which calls html, so "all formats" is just mobi & pdf.
+  BUILD_ALL_FORMATS = %w{mobi pdf}
+end

data/lib/softcover/mathjax.rb

@@ -0,0 +1,85 @@
+module Softcover
+  module Mathjax
+
+    # Returns the MathJax configuration.
+    def self.config(options = {})
+      chapter_number = if options[:chapter_number]
+                         # Call .inspect.inspect to escape the chapter number
+                         # code for interpolation.
+                         options[:chapter_number].inspect.inspect
+                       elsif options[:chapter_number].nil?
+                         '#{chapter_number}'
+                       else  # chapter_number is false, i.e., it's a single page
+                         false
+                       end
+      fn = if chapter_number
+             "formatNumber: function (n) { return #{chapter_number} + '.' + n }"
+           else
+             ""
+           end
+
+      <<-EOS
+      MathJax.Hub.Config({
+        "HTML-CSS": {
+          availableFonts: ["TeX"],
+        },
+        TeX: {
+          extensions: ["AMSmath.js", "AMSsymbols.js"],
+          equationNumbers: {
+            autoNumber: "AMS",
+            #{fn}
+          },
+          Macros: {
+            PolyTeX:    "Poly{\\\\TeX}",
+            PolyTeXnic: "Poly{\\\\TeX}nic",
+            #{custom_macros}
+          }
+        },
+        showProcessingMessages: false,
+        messageStyle: "none",
+        imageFont: null
+      });
+      EOS
+    end
+
+    # Rerturns a version of the MathJax configuration escaped for the server.
+    # There's an extra interpolation somewhere between here and the server,
+    # which this method corrects for.
+    def self.escaped_config
+      self.config.gsub('\\', '\\\\\\\\')
+    end
+
+    MATHJAX  = 'MathJax/MathJax.js?config='
+    AMS_HTML = '/' + MATHJAX + 'TeX-AMS_HTML'
+    AMS_SVG  = MATHJAX + 'TeX-AMS-MML_SVG'
+
+
+    private
+
+      # Returns the custom macros as defined in the custom style file.
+      def self.custom_macros
+        extract_macros(Softcover.custom_styles)
+      end
+
+      # Extracts and formats the macros from the given string of style commands.
+      # The output format is compatible with the macro configuration described
+      # at http://docs.mathjax.org/en/latest/tex.html.
+      def self.extract_macros(styles)
+        # For some reason, \ensuremath doesn't work in MathJax, so remove it.
+        styles.gsub!('\ensuremath', '')
+        # First extract commands with no arguments.
+        cmd_no_args = /^\s*\\newcommand\{\\(.*?)\}\{(.*)\}/
+        cna = styles.scan(cmd_no_args).map do |name, definition|
+          escaped_definition = definition.gsub('\\', '\\\\\\\\')
+          %(#{name}: "#{escaped_definition}")
+        end
+        # Then grab the commands with arguments.
+        cmd_with_args = /^\s*\\newcommand\{\\(.*?)\}\[(\d+)\]\{(.*)\}/
+        cwa = styles.scan(cmd_with_args).map do |name, number, definition|
+          escaped_definition = definition.gsub('\\', '\\\\\\\\')
+          %(#{name}: ["#{escaped_definition}", #{number}])
+        end
+        (cna + cwa).join(",\n")
+      end
+  end
+end

data/lib/softcover/output.rb

@@ -0,0 +1,39 @@
+module Softcover::Output
+  class << self
+    attr_accessor :silent, :stream, :verbosity_level
+
+    def stream
+      silent? ? StringIO.new : (defined?(@stream) && @stream) || $stdout
+    end
+
+    def silence!
+      @silent = true
+    end
+
+    def unsilence!
+      @silent = false
+    end
+
+    def silent?
+      defined?(@silent) && @silent
+    end
+
+    def should_output?(level)
+      !silent? ||
+      !(level && defined?(@verbosity_level) && level < @verbosity_level)
+    end
+  end
+
+  %w{puts printf print}.each do |method|
+    define_method method do |string, options={}|
+      if Softcover::Output.should_output?(options[:level])
+        Softcover::Output.stream.send method, string
+      end
+    end
+  end
+
+  def system(cmd)
+    output = `#{cmd}`
+    puts output
+  end
+end

data/lib/softcover/rails/railtie.rb

@@ -0,0 +1,9 @@
+module Softcover
+  class Railtie < ::Rails::Railtie
+    initializer "softcover", group: :all do |app|
+      path = File.expand_path(File.join(File.dirname(__FILE__),
+        "..", "template", "html", "stylesheets"))
+      app.config.assets.paths << path
+    end
+  end
+end

data/lib/softcover/sanitizer.rb

@@ -0,0 +1,48 @@
+require 'sanitize'
+
+module Softcover
+  module Sanitizer
+    extend self
+
+    # Sanitization suitable for displaying untrusted generated html, while
+    # retaining useful tags and attributes.
+
+    def clean(html)
+      return unless html
+
+      sanitize_options = {
+        elements: %w{div span p a ul ol li h1 h2 h3 h4
+          pre em sup table tbody thead tr td img code strong},
+        remove_contents: %w{script},
+        attributes: {
+          'div' => %w{id class data-tralics-id data-number data-chapter},
+          'a'    => %w{id class href},
+          'span' => %w{id class style},
+          'ol'   => %w{id class},
+          'ul'   => %w{id class},
+          'li'   => %w{id class},
+          'sup'  => %w{id class},
+          'h1'   => %w{id class},
+          'h2'   => %w{id class},
+          'h3'   => %w{id class},
+          'h4'   => %w{id class},
+          'img'  => %w{id class src alt},
+          'em'   => %w{id class},
+          'code' => %w{id class},
+          'strong' => %w{id class},
+          'table'   => %w{id class},
+          'tbody'   => %w{id class},
+          'tr'   => %w{id class},
+          'td'   => %w{id class colspan}
+        },
+        protocols: {
+          'a'   => {'href' => [:relative, 'http', 'https', 'mailto']},
+          'img' => {'src'  => [:relative, 'http', 'https']}
+        },
+        output: :xhtml
+      }
+
+      Sanitize.clean(html.force_encoding("UTF-8"), sanitize_options)
+    end
+  end
+end

data/lib/softcover/server/app.rb

@@ -0,0 +1,78 @@
+require 'sinatra/base'
+require 'sinatra/respond_to'
+require 'sinatra/async'
+
+class Softcover::App < Sinatra::Base
+  register Sinatra::Async
+
+  set :public_folder, 'html'
+  set :bind, '0.0.0.0'
+
+  configure do
+    mime_type :map, 'application/javascript'
+  end
+
+  before do
+    origin = Dir.glob('chapters/*.md').empty? ? :polytex : :markdown
+    @manifest = Softcover::BookManifest.new(origin: origin)
+  end
+
+  get '/' do
+    redirect @manifest.first_chapter.slug
+  end
+
+  get '/main.js' do
+    require 'coffee_script'
+    @mathjax_src    = Softcover::Mathjax::AMS_HTML
+    @mathjax_config = Softcover::Mathjax.escaped_config
+    coffee erb :'main.js'
+  end
+
+  get '/assets/:path' do
+    extension = params[:path].split('.').last
+    content_type extension
+    File.read(File.join(File.dirname(__FILE__),'assets', params[:path]))
+  end
+
+  # Returns the image filename for the local document.
+  def image_filename(path, extension)
+    "html/images/#{path}.#{extension}"
+  end
+
+  get '/:chapter_slug.?:format?' do
+    get_chapter
+    doc = Nokogiri::HTML.fragment(File.read(@chapter.fragment_path))
+    doc.css('a.hyperref').each do |node|
+      node['href'] = node['href'].gsub(/_fragment\.html/, '')
+    end
+    @html = doc.to_xhtml
+
+    if params[:format] == 'js'
+      content_type :html
+      @html
+    else
+      @title = @chapter.menu_heading
+      @local_server = true
+      erb :'book.html'
+    end
+  end
+
+  aget '/:chapter_slug/wait' do
+    require 'json'
+    Signal.trap("SIGINT") { exit 0 }
+    Signal.trap("HUP") do
+      Thread.new { body({ time: Time.now }.to_json) }
+    end
+  end
+
+  not_found do
+    '404'
+  end
+
+  def get_chapter
+    if params[:chapter_slug]
+      @chapter = @manifest.find_chapter_by_slug(params[:chapter_slug])
+      raise Sinatra::NotFound unless @chapter
+    end
+  end
+end