qiita_org 0.1.8 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e8c82431a22c64669538797e28a4063ec88e0716014fec98371f3fa03833fa5
-  data.tar.gz: 060c5ba8fb541193fec02aa66570300d2b3801e5c3ead68339267d514c1ae36f
+  metadata.gz: f0d55c4f00cec8d986bc22dcab5b74ec34d36aad013a00616f68493241055190
+  data.tar.gz: 23ffbb62e9a54b62135a7caa159ef586c8f75d49a85b80a6eb5bfddbeff83a37
 SHA512:
-  metadata.gz: fe04ad5ab1e88a6b722b71e705b0e96fd2378bf19a70f3cdc98e6158ca3c52e707586bd2889c483d249fb658660315445f1d0b0d80402a07f1c597f20a71376d
-  data.tar.gz: e83f076ae7624915c4569f1bc81455882b854d694f0898aab5810825d4653d28356c259657515942c0bc86ea1508f327610fcd228539187ab592f9397d195ba3
+  metadata.gz: c874fbf9c7fde8fe5fde381b109c24024e47187674058efc3be0af9ee3a12acf653e77e626b9cb2b4c1819be8e546599f22f3fb944d620cdcd70de6979582aef
+  data.tar.gz: b7838865703adef0eebd28886ac1d761ff18fe38632819f450421d66a204cf1eeffd292fdb494cfeca4aefbc674d39ba2e5f8d75df53a769847344fc48742f22

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    qiita_org (0.1.4)
+    qiita_org (0.1.10)
       colorize
       command_line (> 2.0.0)
       fileutils

data/lib/qiita_org.rb

@@ -6,6 +6,7 @@ require "qiita_org/config"
 require "qiita_org/get"
 require "qiita_org/list"
 require "qiita_org/get_template"
+require "qiita_org/check_pc_os"
 #require "qiita_org/qiita_org_thor"
 
 module QiitaOrg
@@ -14,6 +15,12 @@ module QiitaOrg
     #      super(*argv)
     #    end
     #
+    def initialize(*argv)
+      super(*argv)
+      checkos = CheckPcOs.new
+      @os = checkos.return_os()
+    end
+
     desc "say_hello", "say_hello"
 
     def say_hello(*name)
@@ -27,7 +34,7 @@ module QiitaOrg
       p ["in qiita_org.rb", argv]
       p file = argv[0] || "README.org"
       p mode = argv[1] || "private"
-      qiita = QiitaPost.new(file, mode)
+      qiita = QiitaPost.new(file, mode, @os)
       begin
         qiita.select_option(mode)
       rescue RuntimeError => e
@@ -59,7 +66,7 @@ module QiitaOrg
     desc "template", "make template.org"
 
     def template(*argv)
-      template = QiitaGetTemplate.new()
+      template = QiitaGetTemplate.new(@os)
     end
 
     desc "all", "post all org file in the directory"

data/lib/qiita_org/check_pc_os.rb

@@ -0,0 +1,19 @@
+class CheckPcOs
+  def initialize()
+    @macos = system "sw_vers"
+    @winos = system "wmic.exe os get caption"
+  end
+
+  def return_os()
+    if @macos
+      return os = "mac"
+    elsif @winos
+      return os = "windows"
+    else
+      return nil
+    end
+  end
+end
+
+#p os = CheckPcOs.new.return_os()
+

data/lib/qiita_org/get_template.rb

@@ -1,9 +1,11 @@
 require "fileutils"
 require "colorize"
+require "kconv"
 require "qiita_org/search_conf_path"
 
 class QiitaGetTemplate
-  def initialize()
+  def initialize(os)
+    @os = os
     cp_template()
     search = SearchConfPath.new(Dir.pwd, Dir.home)
     @conf_dir = search.search_conf_path()
@@ -23,6 +25,32 @@ class QiitaGetTemplate
     File.write("template.org", conts) # + "# {m[1]}: # {m[2]}\n")
   end
 
+  def get_windowsos_version()
+    system 'wmic.exe os get caption > hoge1.txt'
+    system 'wmic.exe os get osarchitecture > hoge2.txt'
+    version1 = Kconv.tosjis(File.read("hoge1.txt"))
+    version2 = Kconv.tosjis(File.read("hoge2.txt"))
+    m1, m2 = [], []
+    m1 = version1.match(/Caption\nMicrosoft (.+) (.+)/)
+    m2 = version2.match(/OSArchitecture\n(.+)-bit/)
+    system 'rm hoge1.txt'
+    system 'rm hoge2.txt'
+    conts = File.read("template.org")
+    conts << "![#{m1[1]}-#{m1[2]}](https://img.shields.io/badge/#{m1[1].gsub(" ", "")}#{m1[2]}-#{m2[1]}bit-brightgreen) "
+    File.write("template.org", conts) # + "# {m[1]}: # {m[2]}\n")
+  end
+
+  def get_ubuntu_version()
+    system 'cat /etc/issue > hoge.txt'
+    version = File.read("hoge.txt")
+    m = []
+    m = version.match(/(.+) (.+) LTS /)
+    system 'rm hoge.txt'
+    conts = File.read("template.org")
+    conts << "![#{m[1]}-#{m[2]}](https://img.shields.io/badge/#{m[1]}-#{m[2]}-brightgreen) "
+    File.write("template.org", conts)
+  end
+
   def get_ruby_version()
     system 'ruby --version > hoge.txt'
     version = File.read("hoge.txt")
@@ -48,12 +76,32 @@ class QiitaGetTemplate
   end
 
   def check_write_contents()
-    ["MacOS", "ruby"].each do |src|
-      print "Write #{src} version?(y/n) "
-      ans = STDIN.gets.chomp
-      next if ans == "n"
-      if ans == "y"
-        send("get_#{src.downcase}_version")
+    if @os == "mac"
+      ["MacOS", "ruby"].each do |src|
+        print "Write #{src} version?(y/n) "
+        ans = STDIN.gets.chomp
+        next if ans == "n"
+        if ans == "y"
+          send("get_#{src.downcase}_version")
+        end
+      end
+    elsif @os == "windows"
+      ["Ubuntu", "ruby"].each do |src|
+        print "Write #{src} version?(y/n) "
+        ans = STDIN.gets.chomp
+        next if ans == "n"
+        if ans == "y"
+          send("get_#{src.downcase}_version")
+        end
+      end
+    else
+      ["ruby"].each do |src|
+        print "Write #{src} version?(y/n) "
+        ans = STDIN.gets.chomp
+        next if ans == "n"
+        if ans == "y"
+          send("get_#{src.downcase}_version")
+        end
       end
     end
   end

data/lib/qiita_org/ox-qmd/ox-qmd.el

@@ -0,0 +1,313 @@
+;;; ox-qmd.el --- Qiita Markdown Back-End for Org Export Engine
+
+;; Copyright (C) 2015-2020 0x60DF
+
+;; Author: 0x60DF <0x60DF@gmail.com>
+;; URL: https://github.com/0x60df/ox-qmd
+;; Version: 1.0.5
+;; Package-Requires: ((org "8.0"))
+;; Keywords: wp
+
+;; This file is not part of GNU Emacs.
+
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This library implements a Markdown back-end (qiita flavor) for
+;; Org exporter, based on `md' back-end and `gfm' back-end.
+
+;; See http://orgmode.org/ for infomation about Org-mode and `md' back-end.
+;; See http://github.com/larstvei/ox-gfm for information about `gfm' back-end.
+
+;;; Code:
+
+(require 'ox-md)
+
+
+;;; User-Configurable Variables
+
+(defvar ox-qmd-language-keyword-alist '(("emacs-lisp" . "el")))
+(defvar ox-qmd-unfill-paragraph t)
+
+
+
+;;; Define Back-End
+
+(org-export-define-derived-backend 'qmd 'md
+  :filters-alist '((:filter-paragraph . org-qmd--unfill-paragraph))
+  :menu-entry
+  '(?9 "Export to Qiita Markdown"
+       ((?0 "To temporary buffer"
+            (lambda (a s v b) (org-qmd-export-as-markdown a s v)))
+        (?9 "To file" (lambda (a s v b) (org-qmd-export-to-markdown a s v)))
+        (?o "To file and open"
+            (lambda (a s v b)
+              (if a (org-qmd-export-to-markdown t s v)
+                (org-open-file (org-qmd-export-to-markdown nil s v)))))
+        (?s "To temporary buffer from subtree"
+            (lambda (a s v b) (org-qmd-export-as-markdown a t v)))))
+  :translate-alist '((headline . org-qmd--headline)
+                     (inner-template . org-qmd--inner-template)
+                     (keyword . org--qmd-keyword)
+                     (strike-through . org-qmd--strike-through)
+                     (underline . org-qmd--undeline)
+                     (src-block . org-qmd--src-block)
+                     (latex-fragment . org-qmd--latex-fragment)
+                     (latex-environment . org-qmd--latex-environment)
+                     (table . org-qmd--table)))
+
+
+
+;;; Filters
+
+(defun org-qmd--unfill-paragraph (paragraph backend info)
+  "Unfill PARAGRAPH element.
+Remove newline from PARAGRAPH and replace line-break string
+with newline in PARAGRAPH if user-configurable variable
+`ox-qmd-unfill-paragraph' is non-nil."
+  (if (and (org-export-derived-backend-p backend 'qmd)
+           ox-qmd-unfill-paragraph)
+      (concat (replace-regexp-in-string
+               "  \n" "\n" (replace-regexp-in-string
+                            "\\([^ ][^ ]\\|[^ ] \\| [^ ]\\)\n" "\\1" paragraph))
+              "\n")
+    paragraph))
+
+
+
+;;; Transcode Functions
+
+(defun org-qmd--headline (headline contents info)
+  "Transcode HEADLINE element into Qiita Markdown format.
+CONTENTS is a content of the HEADLINE. INFO is a plist used
+as a communication channel."
+  (let* ((info (copy-sequence info))
+         (info (plist-put info :with-toc nil)))
+    (org-md-headline headline contents info)))
+
+
+(defun org-qmd--inner-template (contents info)
+  "Return body of document after converting it to Qiita Markdown syntax.
+CONTENTS is the transcoded contents string. INFO is a plist
+holding export options."
+  (let* ((info (copy-sequence info))
+         (info (plist-put info :with-toc nil)))
+    (org-md-inner-template contents info)))
+
+
+(defun org-qmd--keyword (keyword contents info)
+  "Transcode a KEYWORD element into Qiita Markdown format.
+CONTENTS is nil. INFO is a plist used as a communication
+channel."
+  (let* ((info (copy-sequence info))
+         (info (plist-put info :with-toc nil)))
+    (org-html-keyword keyword contents info)))
+
+
+(defun org-qmd--src-block (src-block contents info)
+  "Transcode SRC-BLOCK element into Qiita Markdown format.
+CONTENTS is nil. INFO is a plist used as a communication
+channel."
+  (let* ((lang (org-element-property :language src-block))
+         (lang (or (cdr (assoc lang ox-qmd-language-keyword-alist)) lang))
+         (name (org-element-property :name src-block))
+         (code (org-export-format-code-default src-block info))
+         (prefix (concat "```" lang (if name (concat ":" name) nil) "\n"))
+         (suffix "```"))
+    (concat prefix code suffix)))
+
+
+(defun org-qmd--strike-through (strike-through contents info)
+  "Transcode STRIKE-THROUGH element into Qiita Markdown format.
+CONTENTS is a content of the STRIKE-THROUGH. INFO is a plist
+used as a communication channel."
+  (format "~~%s~~" contents))
+
+
+(defun org-qmd--undeline (underline contents info)
+  "Transcode UNDERLINE element into Qiita Markdown format.
+CONTENTS is a content of the UNDELINE. INFO is a plist used
+as a communication channel."
+  contents)
+
+
+(defun org-qmd--latex-fragment (latex-fragment contents info)
+  "Transcode a LATEX-FRAGMENT element into Qiita Markdown format.
+CONTENTS is nil. INFO is a plist used as a communication
+channel."
+  (replace-regexp-in-string
+   "^\\\\(\\(.+\\)\\\\)$" "$\\1$"
+   (replace-regexp-in-string
+    "^\\\\\\[\\(.+\\)\\\\\\]$" "$$\\1$$"
+    (let* ((info (copy-sequence info))
+           (info (plist-put info :with-latex 'verbatim)))
+      (org-html-latex-fragment latex-fragment contents info)))))
+
+
+(defun org-qmd--latex-environment (latex-environment contents info)
+  "Transcode a LATEX-ENVIRONMENT element into Qiita Markdown format.
+CONTENTS is nil. INFO is a plist used as a communication
+channel."
+  (replace-regexp-in-string
+   "^.*?\\\\begin{.+}.*?$" "```math"
+   (replace-regexp-in-string
+    "^.*?\\\\end{.+}.*?$" "```"
+    (let* ((info (copy-sequence info))
+           (info (plist-put info :with-latex 'verbatim)))
+      (org-html-latex-environment latex-environment contents info)))))
+
+
+(defun org-qmd--table (table contents info)
+  "Transcode a TABLE element into Qiita Markdown format.
+CONTENTS is a content of the table. INFO is a plist used as
+a communication channel."
+  (letrec ((filter (lambda (p l)
+                     (cond ((null l) l)
+                           ((funcall p (car l)) (funcall filter p (cdr l)))
+                           (t (cons (car l) (funcall filter p (cdr l)))))))
+           (zip (lambda (&rest l)
+                  (cond ((null (car l)) (car l))
+                        (t (cons (mapcar 'car l)
+                                 (apply zip (mapcar 'cdr l))))))))
+    (let* ((rows (org-element-map table 'table-row 'identity info))
+           (non-rule-rows
+            (funcall filter (lambda (row)
+                              (eq 'rule (org-element-property :type row)))
+                     rows))
+           (alignments (org-element-map (car non-rule-rows) 'table-cell
+                         (lambda (cell)
+                           (org-export-table-cell-alignment cell info))
+                         info))
+           (widths (mapcar
+                    (lambda (column)
+                      (let ((max-difference
+                             (apply
+                              'max (mapcar
+                                    (lambda (cell)
+                                      (- (org-element-property :end cell)
+                                         (org-element-property :begin cell)))
+                                    column))))
+                        (if (< max-difference 4) 3 (- max-difference 1))))
+                    (apply
+                     zip (mapcar
+                          (lambda (row)
+                            (org-element-map row 'table-cell 'identity info))
+                          non-rule-rows))))
+           (joined-rows
+            (mapcar (lambda (row)
+                      (let ((cells
+                             (org-element-map row 'table-cell 'identity info)))
+                        (mapconcat
+                         (lambda (tuple)
+                           (let ((alignment (car tuple))
+                                 (width (cadr tuple))
+                                 (cell (caddr tuple)))
+                             (format (format " %%-%ds" (- width 1))
+                                     (or (org-export-data
+                                          (org-element-contents cell)
+                                          info)
+                                         ""))))
+                         (funcall zip alignments widths cells)
+                         "|")))
+                    non-rule-rows))
+           (joined-rows-with-delimiter-row
+            (cons (car joined-rows)
+                  (cons (mapconcat
+                         (lambda (tuple)
+                           (let ((alignment (car tuple))
+                                 (width (cadr tuple)))
+                             (format "%s%s%s"
+                                     (if (memq alignment '(left center))
+                                         ":" "-")
+                                     (make-string (- width 2) ?-)
+                                     (if (memq alignment '(right center))
+                                         ":" "-"))))
+                         (funcall zip alignments widths)
+                         "|")
+                        (cdr joined-rows)))))
+      (mapconcat (lambda (row) (format "|%s|" row))
+                 joined-rows-with-delimiter-row
+                 "\n"))))
+
+
+
+;;; Interactive function
+
+;;;###autoload
+(defun org-qmd-export-as-markdown (&optional async subtreep visible-only)
+  "Export current buffer to a Qiita Markdown buffer.
+
+If narrowing is active in the current buffer, only export
+its narrowed part.
+
+If a region is active, export that region.
+
+A non-nil optional argument ASYNC means the process should
+happen asynchronously. The resulting buffer should be
+accessible through the `org-export-stack' interface.
+
+When optional argument SUBTREEP is non-nil, export the
+sub-tree at point, extracting information from the headline
+properties first.
+
+When optional argument VISIBLE-ONLY is non-nil, don't export
+contents of hidden elements.
+
+Export is done in a buffer named \"*Org QMD Export*\", which
+will be displayed when
+`org-export-show-temporary-export-buffer' is non-nil."
+  (interactive)
+  (org-export-to-buffer 'qmd "*Org QMD Export*"
+    async subtreep visible-only nil nil (lambda () (text-mode))))
+
+;;;###autoload
+(defun org-qmd-convert-region-to-md ()
+  "Convert region into Qiita Markdown format.
+Assume the current region has org-mode syntax, and convert
+it to Qiita Markdown. This can be used in any buffer. For
+example, you can write an itemized list in org-mode syntax
+in a Markdown buffer and use this command to convert it."
+  (interactive)
+  (org-export-replace-region-by 'qmd))
+
+
+;;;###autoload
+(defun org-qmd-export-to-markdown (&optional async subtreep visible-only)
+  "Export current buffer to a Qiita Markdown file.
+
+If narrowing is active in the current buffer, only export
+its narrowed part.
+
+If a region is active, export that region.
+
+A non-nil optional argument ASYNC means the process should
+happen asynchronously. The resulting file should be
+accessible through the `org-export-stack' interface.
+
+When optional argument SUBTREEP is non-nil, export the
+sub-tree at point, extracting information from the headline
+properties first.
+
+When optional argument VISIBLE-ONLY is non-nil, don't export
+contents of hidden elements.
+
+Return output file's name."
+  (interactive)
+  (let ((outfile (org-export-output-file-name ".md" subtreep)))
+    (org-export-to-file 'qmd outfile async subtreep visible-only)))
+
+(provide 'ox-qmd)
+
+;;; ox-qmd.el ends here

data/lib/qiita_org/post.rb

@@ -7,9 +7,10 @@ require "colorize"
 require "qiita_org/search_conf_path.rb"
 
 class QiitaPost
-  def initialize(file, option)
+  def initialize(file, option, os)
     @src = file
     @option = (option == "qiita" || option == "open")? "public" : option
+    @os = os
     search = SearchConfPath.new(Dir.pwd, Dir.home)
     @conf_dir = search.search_conf_path()
     p @conf_dir
@@ -39,7 +40,8 @@ class QiitaPost
     @conf = JSON.load(File.read(conf_path))
     @access_token = @conf["access_token"]
     @teams_url = @conf["teams_url"]
-    @ox_qmd_load_path = @conf["ox_qmd_load_path"]
+    lib = File.expand_path("../../../lib", __FILE__)
+    @ox_qmd_load_path = File.join(lib, "qiita_org", "ox-qmd", "ox-qmd") # @conf["ox_qmd_load_path"]
   end
 
   # src.org -> src.md
@@ -136,6 +138,17 @@ class QiitaPost
     end
   end
 
+  # open qiita
+  def open_qiita()
+    if @os == "mac"
+      system "open #{@res_body["url"]}"
+    elsif @os == "windows"
+      system "explorer.exe #{@res_body["url"]}"
+    else
+      system "open #{@res_body["url"]}"
+    end
+  end
+
   def run()
     get_title_tags()
     set_config()
@@ -146,8 +159,7 @@ class QiitaPost
     qiita_post()
     get_and_print_qiita_return()
 
-    # open qiitta
-    system "open #{@res_body["url"]}"
+    open_qiita()
 
     add_qiita_id_on_org()
   end

data/lib/qiita_org/version.rb

@@ -1,3 +1,3 @@
 module QiitaOrg
-  VERSION = "0.1.8"
+  VERSION = "0.1.13"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qiita_org
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.13
 platform: ruby
 authors:
 - Kenta Yamamoto
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-01 00:00:00.000000000 Z
+date: 2020-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -953,12 +953,14 @@ files:
 - hoge.rb
 - lib/qiita_org.rb
 - lib/qiita_org/.qiita.conf
+- lib/qiita_org/check_pc_os.rb
 - lib/qiita_org/config.json
 - lib/qiita_org/config.rb
 - lib/qiita_org/get.rb
 - lib/qiita_org/get_template.rb
 - lib/qiita_org/hoge.txt
 - lib/qiita_org/list.rb
+- lib/qiita_org/ox-qmd/ox-qmd.el
 - lib/qiita_org/post.rb
 - lib/qiita_org/search_conf_path.rb
 - lib/qiita_org/template.org
@@ -968,7 +970,7 @@ homepage: https://github.com/yamatoken/qiita_org
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -984,7 +986,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.4
-signing_key: 
+signing_key:
 specification_version: 4
 summary: this is qiita post gem from org.
 test_files: []