gibier 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2c145bc519db0917358e75d76d5865b3a8a1da2
+  data.tar.gz: e427319ab75b34e7ce5f046c3ea052e1bd19c955
+SHA512:
+  metadata.gz: a2c4d87985b5a11e0a62f1322aaa809edd7b1a9800dba1f140c38252d3cd20157cfee191823b914fad2f8ff2b9aea58c9a676ea7df636d1cab048bec598fc1f1
+  data.tar.gz: 863719dbeb82a79007af47f551066a731269927b296cb059b104acd068e3fcd133a23ab1a35d9085199245004e29c2952d471508fe2a9eb2d3034da4ff65a34e

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gibier"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/gibier

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'gibier'
+
+Gibier::Cli.start(ARGV)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/gibier.rb

@@ -0,0 +1,8 @@
+require "gibier/version"
+
+module Gibier
+end
+
+require "gibier/slide_helper"
+require "gibier/slide_loader"
+require 'gibier/cli'

data/lib/gibier/cli.rb

@@ -0,0 +1,95 @@
+require 'thor'
+require 'fileutils'
+require 'pathname'
+require 'rouge'
+require 'opal'
+require 'haml'
+
+module Gibier
+  class Cli < Thor
+    desc 'new', 'create new project'
+
+    def new(name)
+      puts "Create new project '#{name}'"
+
+      FileUtils.mkdir name
+      dir = Dir.new(__dir__+'/../../template/project')
+      dir.each do |file|
+        next if file == '..'
+        FileUtils.cp_r(dir.path + '/' + file, name)
+      end
+    end
+
+    desc 'highlight', 'generate highlight.css'
+
+    def highlight
+      puts Rouge::Themes::Base16.mode(:dark).render(scope: '.highlight')
+    end
+
+    desc 'ghpages', 'create static pages'
+
+    def ghpages
+      puts "Create static pages"
+
+      FileUtils.mkdir_p 'docs'
+      assets_dir = Dir.new(__dir__ + '/../../template/project/assets')
+      FileUtils.cp_r(assets_dir.path, 'docs')
+
+      slide_loader = Gibier::SlideLoader.new
+      Gibier::SlideHelper.each_slides('data') do |name|
+        slide_loader.init_slide(name)
+
+        FileUtils.mkdir_p "docs/assets/#{name}"
+        FileUtils.cp_r("data/#{name}/css", "docs/assets/#{name}")
+        FileUtils.cp_r("data/#{name}/images", "docs/assets/#{name}")
+
+        FileUtils.mkdir_p "docs/#{name}"
+        convert_html(File.expand_path('../../../template/gh_pages/slide.haml', __FILE__), "docs/#{name}/index.html", slide_name: name)
+
+        FileUtils.mkdir_p "docs/assets/#{name}/javascripts"
+        build(name, "docs/assets/#{name}/javascripts/application.js")
+      end
+
+      convert_html(File.expand_path('../../../template/gh_pages/index.haml', __FILE__), "docs/index.html", slides: slide_loader.slides)
+    end
+
+    private
+
+    def convert_html(haml_file, html_file, **instance_vars)
+      File.open(html_file, "w") do |f|
+        engine = Haml::Engine.new(File.read(haml_file))
+        context = Object.new
+        instance_vars.each do |key, value|
+          context.instance_variable_set(:"@#{key}", value)
+        end
+        f.write engine.render(context) # Tilt::StringTemplate.new().render
+      end
+    end
+
+    def build(name, filename)
+      builder = Opal::Builder.new
+
+      use_gem(builder, 'opal-browser', 'opal')
+      use_gem(builder, 'opal-router', 'opal')
+      use_gem(builder, 'hyalite', 'client')
+
+      builder.append_paths './app'
+      builder.use_gem 'gibier'
+      builder.use_gem 'paggio'
+      builder.build "./app/slides/#{name}/app.rb"
+
+      File.open(filename, 'w') do |file|
+        file.write builder.to_s
+      end
+
+    end
+
+    def use_gem(builder, name, opal_path)
+      spec = Gem::Specification.find_by_name name
+      lib_path = Pathname.new spec.full_require_paths.first
+      opal_path = lib_path.parent + opal_path
+      builder.append_paths opal_path.to_s
+    end
+  end
+end
+

data/lib/gibier/render.rb

@@ -0,0 +1,234 @@
+require 'unindent'
+require 'rouge'
+require 'redcarpet'
+
+class String
+  def escape
+    if self =~ /<a>(.*)<\/a>/
+      "a(#{$1})"
+    elsif self =~ /<p>(.*)<img>(.*)<\/img><\/p>/
+      "p(#{$1}, img(#{$2}))"
+    elsif self =~ /<div>(.*)<\/div>/
+      "div(#{$1})"
+    elsif self =~ /<strong>(.*)<\/strong>/
+      "strong(nil, \"#{$1}\")"
+    else
+      "\"#{self.gsub(/\"/, "\\\"").gsub(/\\/, "\\\\")}\""
+    end
+  end
+end
+
+module Gibier
+  class Renderer < Redcarpet::Render::Base
+    def self.create(name)
+      Class.new(Renderer) do
+        def self.page_name
+          @page_name
+        end
+
+        def self.page_name=(name)
+          @page_name = name
+        end
+
+        def page_name
+          self.class.page_name
+        end
+      end.tap{|c| c.page_name = name }
+    end
+
+    def initialize
+      super
+      @enter_title_page = false
+      @enter_page = false
+      @page_count = 0
+      clear_list_state
+    end
+
+    def clear_list_state
+      @enter_list = false
+      @list_depth = 0
+    end
+
+    [
+      # block-level calls
+      :block_quote,
+
+      # span-level calls
+      :autolink,
+      :underline, :raw_html,
+      :triple_emphasis, :strikethrough,
+      :superscript, :highlight,
+
+      # footnotes
+      :footnotes, :footnote_def, :footnote_ref,
+
+      # low level rendering
+      #:entity, :normal_text
+    ].each do |method|
+      define_method method do |*args|
+        "#{method} #{args.first}"
+      end
+    end
+
+    def hrule
+      clear_list_state
+      "".tap do |result|
+        if @enter_title_page || @enter_page
+          result <<
+<<EOD
+  end
+end
+end
+
+EOD
+          @enter_title_page = @enter_page = false
+        end
+
+        result << <<EOD
+class Gibier::Page#{@page_count} < Gibier::PageBase
+def content
+  [].tap do |children|
+EOD
+
+        @enter_page = true
+        @page_count += 1
+      end
+    end
+
+    def header(text, header_level)
+      clear_list_state
+
+      if header_level > 3
+        return "      children << h#{header_level}(nil, #{text.escape})\n"
+      end
+
+      "".tap do |result|
+        if @enter_title_page || @enter_page
+          result <<
+<<EOD
+  end
+end
+end
+
+EOD
+          @enter_title_page = @enter_page = false
+        end
+
+        if header_level == 1
+          @enter_title_page = true
+          @title = text.escape
+        else
+          @enter_page = true
+        end
+
+
+        result <<
+<<EOD
+class Gibier::Page#{@page_count} < Gibier::PageBase
+def header
+  h#{header_level}(nil, #{text.escape})
+end
+
+def content
+  [].tap do |children|
+EOD
+
+        @page_count += 1
+      end
+    end
+
+    def doc_footer(*args)
+<<EOD
+  end
+end
+end
+
+Gibier.page_count = #{@page_count}
+Gibier.title = #{@title}
+EOD
+    end
+
+    def list_item(item, orderd)
+      "".tap do |result|
+        if item =~ /.*\n +children << /
+          result << item.sub(/(.*)\n +children << /) { "                  li(nil, #{$1.strip.escape}),\n                  " }.rstrip
+          result << ",\n"
+          @enter_list = false
+        else
+          result << "                    li(nil, #{item.strip.escape}),\n"
+        end
+      end
+    end
+
+    def list(text, ordered)
+      "".tap do |result|
+        result << "      children << ul(nil,\n"
+        result << text.sub(/,\n\z/, "\n")
+        result << "      )\n"
+        @enter_list = false
+      end
+    end
+
+    def link(link, title, content)
+      link or return
+      "<a>{href: #{link.escape}, target: \"_blank\"}, #{content.escape}</a>"
+    end
+
+    def image(link, title, alt_text)
+      href = "\#{Gibier.assets_path}/images/#{link}"
+      "<p>{class: \"#{alt_text}\"}<img>{src: #{href.escape}}</img></p>"
+    end
+
+    def block_code(code, language)
+      clear_list_state
+
+      formatter = Rouge::Formatters::HTML.new(css_class: 'highlight', line_numbers: true)
+      lexer = case language
+              when 'ruby'
+                Rouge::Lexers::Ruby.new
+              when 'javascript'
+                Rouge::Lexers::Javascript.new
+              else
+                Rouge::Lexers::PlainText.new
+              end
+      highlight = formatter.format(lexer.lex(code))
+      "      children << code({ dangerouslySetInnerHTML: { __html: %q{#{highlight}} } })\n"
+    end
+
+    def block_html(html)
+      clear_list_state
+      "      children << code({ dangerouslySetInnerHTML: { __html: %q{#{html}} } })\n"
+    end
+
+    def emphasis(*args)
+      "# #{args}"
+    end
+
+    def double_emphasis(*args)
+      "<strong>#{args.first}</strong>"
+    end
+
+    def paragraph(text)
+      lines = text.split(/  $/)
+      if text[0] == '%'
+        class_name = text[1...text.index(':')]
+        lines[0] = lines.first[(lines.first.index(':') + 1)...lines.first.length].lstrip
+        "      children << p({className:\"#{class_name}\"}, #{lines.map{|l| l.escape}.join(',Hyalite.create_element(\'br\'),')})\n"
+      else
+        "      children << p(nil, #{lines.map{|l| l.escape}.join(',Hyalite.create_element(\'br\'),')})\n"
+      end
+    end
+
+    def table(header, body)
+      "#{header}#{body}"
+    end
+
+    def table_row(content)
+      content + "\n"
+    end
+
+    def table_cell(content, alignment)
+      content + "\t"
+    end
+  end
+end

data/lib/gibier/slide_helper.rb

@@ -0,0 +1,25 @@
+module Gibier
+  class SlideHelper
+    def self.each_slides(dir = 'data')
+      Dir.foreach(dir) do |dir_name|
+        if !dir_name.start_with?('.') && File.directory?("#{dir}/#{dir_name}")
+          yield dir_name
+        end
+      end
+    end
+
+    def self.slides(dir = 'data')
+      SlideIterator.new(dir).to_enum
+    end
+
+    class SlideIterator
+      def initialize(dir)
+        @dir = dir
+      end
+
+      def each(&block)
+        SlideHelper.each_slides(@dir, &block)
+      end
+    end
+  end
+end

data/lib/gibier/slide_loader.rb

@@ -0,0 +1,77 @@
+require 'rouge'
+require 'fssm'
+require 'eventmachine'
+require 'redcarpet'
+
+require_relative './render'
+
+module Gibier
+  class SlideLoader
+
+    attr_reader :slides
+
+    def initialize
+      @slides = []
+    end
+
+    def init_slide(name)
+      Dir.mkdir('app/slides') unless Dir.exist?('app/slides')
+      Dir.mkdir('app/scripts') unless Dir.exist?('app/scripts')
+      Dir.mkdir(SlideLoader.src_path(name)) unless Dir.exist?(SlideLoader.src_path(name))
+      Dir.mkdir(SlideLoader.script_path(name)) unless Dir.exist?(SlideLoader.script_path(name))
+
+      File.foreach("data/#{name}/slide.md") do |line|
+        if line =~ /\A# (.+)/
+          @slides << {name: name, title: $1}
+          break
+        end
+      end
+
+      SlideLoader.load_slide(name)
+    end
+
+    def self.load_slide(name)
+      File.open("#{src_path(name)}/pages.rb", "w+") do |f|
+        data = File.read("data/#{name}/slide.md")
+        markdown = Redcarpet::Markdown.new(Gibier::Renderer.create(name), fenced_code_blocks: true)
+        f.write markdown.render(data)
+      end
+
+      if File.exist?("data/#{name}/script.md")
+        File.open("#{script_path(name)}/script.html", "w+") do |f|
+          script = File.read("data/#{name}/script.md")
+          markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML.new(hard_wrap: true), autolink: true, fenced_code_blocks: true)
+          f.write markdown.render(script)
+        end
+      end
+
+      File.open("#{src_path(name)}/app.rb", "w+") do |f|
+        f.write Tilt::StringTemplate.new(File.expand_path('../../../template/app.rb', __FILE__)).render(Object.new, name: name)
+      end
+
+      File.open("#{src_path(name)}/script.rb", "w+") do |f|
+        f.write Tilt::StringTemplate.new(File.expand_path('../../../template/script.rb', __FILE__)).render(Object.new, name: name)
+      end
+    end
+
+    def self.src_path(name)
+      "app/slides/#{name}"
+    end
+
+    def self.script_path(name)
+      "app/scripts/#{name}"
+    end
+
+    def add_slide(name)
+      init_slide(name)
+
+      EM.defer do
+        FSSM.monitor("data/#{name}", %w(slide.md script.md)) do
+          update {|base, relative| Gibier::SlideLoader.load_slide(name) }
+          delete {|base, relative|}
+          create {|base, relative|}
+        end
+      end
+    end
+  end
+end