hyla 1.0

data/lib/hyla/commands/new.rb

@@ -0,0 +1,82 @@
+module Hyla
+  module Commands
+    class New < Command
+
+      def self.process(args, options = {})
+        raise ArgumentError.new('You must specify a destination.') if args.empty?
+
+        @config = Hyla::Configuration.new
+
+        #
+        # Create Directory for the Project
+        #
+        new_project_path = File.expand_path(args.join(" "), Dir.pwd)
+
+        if Dir.exist? new_project_path
+
+          Hyla.logger.debug("Dir exists: #{new_project_path}")
+
+          # If force is selected, then we delete & recreate it to clen content
+          if options[:force]
+            Hyla.logger.debug("Force option selected")
+            # DOES NOT WORK ON Mac OS X
+            # FileUtils.rmdir(new_project_path)
+            FileUtils.rm_rf new_project_path
+            # Create Directory
+            FileUtils.mkdir_p new_project_path
+            Hyla.logger.debug("Dir recreated it")
+          end
+
+          # Preserve content if it exists
+          if preserve_content?(new_project_path)
+            Hyla.logger.error "Conflict: ", "#{new_project_path} exists and is not empty."
+            exit(1)
+          end
+
+        else
+          # Create Directory
+          FileUtils.mkdir_p new_project_path
+        end
+
+        #
+        # Create blank project
+        # or copy sample project from template directory
+        #
+        if options[:blank]
+          create_blank_project new_project_path
+        else
+          raise ArgumentError.new('You must specifiy a template type.') if options[:template_type].nil?
+          create_sample_project(new_project_path, options[:template_type])
+        end
+
+      end
+
+      #
+      # Create Blank Project
+      # with just a readme.adoc file
+      def self.create_blank_project(path)
+        Dir.chdir(path) do
+          f = File.open('sample.adoc', 'w')
+          f.puts "= Sample Asciidoctor Project"
+          f.puts "This is an empty AsciidocTor file."
+          f.puts "To create **asciidoc(tor)** content, more info are available http://asciidoctor.org/docs/user-manual[here]"
+        end
+      end
+
+      # Create a Sample Project
+      # from a Template
+      def self.create_sample_project(path, type)
+        # TODO Test with ['',''] * '/'
+        source = @config.templates + '/' + type + '/.'
+        FileUtils.cp_r source, path
+      end
+
+      #
+      # Preserve source location is folder is not empty
+      def self.preserve_content?(path)
+        !Dir["#{path}/**/*"].empty?
+      end
+
+    end # class
+  end # module Commands
+end # module Hyla

data/lib/hyla/commands/publish.rb

@@ -0,0 +1,8 @@
+module Hyla
+  module Commands
+    class Publish < Command
+
+
+    end # class
+  end # module Commands
+end # module Hyla

data/lib/hyla/commands/reload.rb

@@ -0,0 +1,109 @@
+module Hyla
+  module Commands
+    class Reload < Command
+
+      attr_reader :web_sockets, :thread, :options
+
+      DEFAULT_OPTIONS = {
+          host: '0.0.0.0',
+          port: '35729',
+          apply_css_live: true,
+          override_url: false,
+          grace_period: 0
+      }
+
+      @@web_sockets = []
+
+      def initialize()
+      end
+
+      def process(options)
+        @options = DEFAULT_OPTIONS.clone.merge(options)
+        @Websocket ||= Hyla::WebSocket
+        _start
+      end
+
+      def reload_browser(paths = [])
+        Hyla.logger.info "Reloading browser: #{paths.join(' ')}"
+        paths.each do |path|
+          Hyla.logger.info(path)
+          data = _data(path)
+          Hyla.logger.info(">> Data received : #{data}")
+          @@web_sockets.each { |ws| ws.send(MultiJson.encode(data)) }
+        end
+      end
+
+      def reload_browser2(paths = [])
+        Hyla.logger.info "Reloading browser: #{paths.join(' ')}"
+        paths.each do |path|
+          Hyla.logger.info(path)
+          data = 'hyla/development/'
+          Hyla.logger.info(">> Data received : #{data}")
+          @@web_sockets.each { |ws| ws.send(MultiJson.encode(data)) }
+        end
+      end
+
+      private
+
+      def _start
+        _start_reactor
+      end
+
+      def _stop
+        thread.kill
+      end
+
+      def _data(path)
+
+        # TODO Improve that
+        # path:    "#{Dir.pwd}/#{path}",
+
+        data = {
+            command: 'reload',
+            path: "#{path}",
+            liveCSS: @options[:apply_css_live]
+        }
+        if options[:override_url] && File.exist?(path)
+          data[:overrideURL] = '/' + path
+        end
+        data
+      end
+
+      def _start_reactor
+        Hyla.logger.info "LiveReload is waiting for a browser to connect."
+        EventMachine.epoll
+        EventMachine.run do
+          EventMachine.start_server(@options[:host], @options[:port], @Websocket, {}) do |ws|
+            ws.onopen { _connect(ws) }
+            ws.onclose { _disconnect(ws) }
+            ws.onmessage { |msg| _print_message(msg) }
+          end
+        end
+      end
+
+      def _connect(ws)
+        Hyla.logger.info "Browser connected."
+        ws.send MultiJson.encode(
+                    command: 'hello',
+                    protocols: ['http://livereload.com/protocols/official-7'],
+                    serverName: 'guard-livereload'
+                )
+        @@web_sockets << ws
+      rescue
+        Hyla.logger.error $!
+        Hyla.logger.error $!.backtrace
+      end
+
+      def _disconnect(ws)
+        Hyla.logger.info "Browser disconnected."
+        @@web_sockets.delete(ws)
+      end
+
+      def _print_message(message)
+        message = MultiJson.decode(message)
+        Hyla.logger.info "Browser URL: #{message['url']}" if message['command'] == 'url'
+      end
+
+    end # class
+  end # module Commands
+end # module Hyla

data/lib/hyla/commands/serve.rb

@@ -0,0 +1,59 @@
+module Hyla
+  module Commands
+    class Serve < Command
+
+      def self.process(args, options)
+        include WEBrick
+
+        my_opts = options
+
+        destination = options[:out_dir]
+
+        my_opts[:Port] = options[:port]
+        my_opts[:BindAddress] = options[:host]
+        my_opts[:MimeTypes] = self.mime_types
+        my_opts[:DoNotReverseLookupmy_opts] = true
+        my_opts[:StartCallback] = start_callback(options[:detach])
+        my_opts[:AccessLog] = []
+        my_opts[:Logger] = Log::new([], Log::WARN)
+        my_opts[:baseurl] = options[:baseurl]
+
+        # recreate NondisclosureName under utf-8 circumstance
+        fh_option = WEBrick::Config::FileHandler
+        fh_option[:NondisclosureName] = ['.ht*','~*']
+        # Option added to allow to navigate into the directories
+        fh_option[:FancyIndexing] = true
+
+        #s = HTTPServer.new(webrick_options(my_opts))
+        s = HTTPServer.new(my_opts)
+
+        s.mount(my_opts[:baseurl],HTTPServlet::FileHandler, destination, fh_option)
+
+        Hyla.logger.info "Server address:", "http://#{s.config[:BindAddress]}:#{s.config[:Port]}"
+
+        if options[:detach] # detach the server
+          pid = Process.fork { s.start }
+          Process.detach(pid)
+          Hyla.logger.info "Server detatched with pid '#{pid}'.", "Run `kill -9 #{pid}' to stop the server."
+        else # create a new server thread, then join it with current terminal
+          t = Thread.new { s.start }
+          trap("INT") { s.shutdown }
+          t.join()
+        end
+      end
+
+
+      def self.start_callback(detached)
+        unless detached
+          Proc.new { Hyla.logger.info "Server running...", "press ctrl-c to stop." }
+        end
+      end
+
+      def self.mime_types
+        mime_types_file = File.expand_path('../../../data/mime.types', File.dirname(__FILE__))
+        WEBrick::HTTPUtils::load_mime_types(mime_types_file)
+      end
+
+    end # class
+  end # module Commands
+end # module Hyla

data/lib/hyla/commands/watch.rb

@@ -0,0 +1,172 @@
+module Hyla
+  module Commands
+    class Watch < Command
+
+      DEFAULT_OPTIONS = {
+          :watch_dir => '.',
+          :watch_ext => %w(ad adoc asc asciidoc txt index),
+          :run_on_start => false,
+          :backend => 'html5',
+          :eruby => 'erb',
+          :doctype => 'article',
+          :compact => false,
+          :attributes => {},
+          :always_build_all => false,
+          :to_dir => '.',
+          :to_file => '',
+          :safe => :unsafe,
+          :header_footer => true
+      }
+
+      WS_OPTIONS = {
+          :base_url => '/modules'
+      }
+
+      def initialize
+      end
+
+      def init(watchers = [], options = {})
+        watchers = [] if !watchers
+        merged_opts = DEFAULT_OPTIONS.clone
+
+        if options.has_key? :watch_dir
+          merged_opts[:watch_dir] = options.delete :watch_dir
+          # set output to input if input is specified, but not output
+          unless options.has_key? :to_dir
+            merged_opts[:to_dir] = merged_opts[:watch_dir]
+          end
+        end
+
+        merged_opts.merge! options
+
+        # house cleaning
+        merged_opts[:watch_dir] = '.' if merged_opts[:watch_dir].to_s.empty?
+        merged_opts.delete(:to_dir) if (merged_opts[:to_dir] == '.' || merged_opts[:to_dir].to_s.empty?)
+
+        if merged_opts[:watch_dir] == '.'
+          input_re = ''
+        else
+          merged_opts[:watch_dir].chomp!('/') while merged_opts[:watch_dir].end_with?('/')
+          merged_opts[:watch_dir] << '/'
+          input_re = Regexp.escape merged_opts[:watch_dir]
+        end
+
+        watch_re = %r{^#{input_re}.+\.(?:#{merged_opts[:watch_ext] * '|'})$}
+        watchers << ::Guard::Watcher.new(watch_re)
+        merged_opts[:attributes] = {} unless merged_opts[:attributes]
+        # set a flag to indicate running environment
+        merged_opts[:attributes]['guard'] = ''
+      end
+
+      def self.start_livereload
+        @reload = Hyla::Commands::Reload.new
+        Thread.new { @reload.process(WS_OPTIONS) }
+      end
+
+      def self.process(args, options = {})
+
+        # Start LiveReload
+        self.start_livereload
+
+        @opts = DEFAULT_OPTIONS.clone
+
+        if options.has_key? :destination
+          @opts[:to_dir] = File.expand_path options[:destination]
+        end
+
+        if options.has_key? :source
+          @opts[:watch_dir] = File.expand_path options[:source]
+        end
+
+        @received_opts = options
+
+        #
+        # Guard Listen Callback
+        # Detect files modified, deleted or added
+        #
+        callback = Proc.new do |modified, added, removed|
+          Hyla.logger.info "modified absolute path: #{modified}"
+          Hyla.logger.info "added absolute path: #{added}"
+          Hyla.logger.info "removed absolute path: #{removed}"
+
+          if !modified.nil? or !added.nil?
+            modified.each do |modify|
+              Hyla.logger.info "File modified : #{modify}"
+              call_asciidoctor(modify)
+            end
+            added.each do |add|
+              Hyla.logger.info "File added : #{add}"
+              call_asciidoctor(add)
+            end
+          end
+        end # callback
+
+        Hyla.logger.info ">> ... Starting"
+        Hyla.logger.info ">> Hyla has started to watch files in this output dir :  #{@opts[:watch_dir]}"
+        Hyla.logger.info ">> Results of Asciidoctor generation will be available here : #{@opts[:to_dir]}"
+
+        # TODO : Investigate issue with Thread pool is not running (Celluloid::Error)
+        # when using a more recent version of guard listen
+        listener = Listen.to!(@opts[:watch_dir], &callback)
+
+        trap(:INT) {
+          Hyla.logger.info "Interrupt intercepted"
+          Thread.kill
+        }
+      end
+
+      # listen
+
+      def self.call_asciidoctor(f)
+        dir_file = File.dirname(f)
+        file_to_process = Pathname.new(f).basename
+        @ext_name = File.extname(file_to_process)
+        Hyla.logger.info ">> Directory of the file to be processed : #{dir_file}"
+        Hyla.logger.info ">> File to be processed : #{file_to_process}"
+        Hyla.logger.info ">> Extension of the file : #{@ext_name}"
+
+        if @ext_name != '.html'
+          to_file = file_to_process.to_s.gsub('adoc', 'html')
+          @opts[:to_file] = to_file
+
+          # TODO Check why asciidoctor populates new attributes and remove to_dir
+          # TODO when it is called a second time
+          # Workaround - reset list, add again :out_dir
+          @opts[:attributes] = {}
+          @opts[:to_dir] = @received_opts[:destination]
+
+          # Calculate Asciidoc to_dir relative to the dir of the file to be processed
+          # and create dir in watched dir
+          rel_dir = substract_watch_dir(dir_file, @opts[:watch_dir])
+          if !rel_dir.empty?
+            calc_dir = File.expand_path @opts[:to_dir] + rel_dir
+            FileUtils.makedirs calc_dir
+          else
+            calc_dir = File.expand_path @opts[:to_dir]
+          end
+
+          @opts[:to_dir] = calc_dir
+
+          Hyla.logger.info ">> Directory of the file to be generated : #{calc_dir}"
+          Hyla.logger.debug ">> Asciidoctor options : #{@opts}"
+
+          # Render Asciidoc document
+          Asciidoctor.render_file(f, @opts)
+
+          # Refresh browser connected using LiveReload
+          path = []
+          path.push(calc_dir)
+          # TODO
+          @reload.reload_browser(path)
+        end
+      end
+
+      def self.substract_watch_dir(file_dir, watched_dir)
+        s = file_dir.sub(watched_dir, '')
+        Hyla.logger.info ">> Relative directory : #{s}"
+        s
+      end
+
+    end # class
+  end # module Commands
+end # module Hyla

data/lib/hyla/configuration.rb

@@ -0,0 +1,47 @@
+module Hyla
+  class Configuration
+
+    attr_reader :HEADER, :INDEX_SUFFIX, :HEADER_INDEX, :INCLUDE_PREFIX, :INCLUDE_SUFFIX, :LEVEL_1, :LEVEL_2, :SKIP_CHARACTERS,
+                :ADOC_EXT, :PREFIX_ARTEFACT, :TEMPLATES
+
+    def initialize()
+
+      @INCLUDE_PREFIX = 'include::'
+      @INCLUDE_SUFFIX = '[]'
+
+      @INDEX_SUFFIX = '_AllSlides.index'
+
+      @HEADER = ":data-uri:\n" +
+                ":icons: font\n" +
+                ":last-update-label!:\n" +
+                ":source-highlighter: coderay\n" +
+                ":toc: left\n" +
+                "\n"
+
+      @HEADER_INDEX = ":data-uri:\n" +
+                      ":navigation:\n" +
+                      ":menu:\n" +
+                      ":status:\n" +
+                      "\n"
+
+      @LEVEL_1 = '= '
+
+      @LEVEL_2 = '== '
+
+      @SKIP_CHARACTERS = '>>'
+
+      @ADOC_EXT = '.adoc'
+
+      @PREFIX_ARTEFACT  = 'asciidoc_'
+
+      @TEMPLATES = '../../lib/templates'
+
+    end
+
+    # Templates Location
+    def templates
+      File.expand_path(@TEMPLATES, File.dirname(__FILE__))
+    end
+
+  end # Class Artefact
+end # module Hyla