qiita_org 0.1.4 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e1d39ee46dabf4d2acd53bd27ad8f825a1717981cd63231c2431e531f5cf8ee
-  data.tar.gz: 5e6e874f3f83341978fba00585728811dfebf001e4cccc159ea24c958aa9aeb0
+  metadata.gz: 9e7a075ad1c16002e53fff794d556f9ce5bb2c6e7d5e37768a37a8deb59f28e9
+  data.tar.gz: aad3df025127c3e87d3ccb71a262f28083904d63b12e7371cea4c80cf68ecdf1
 SHA512:
-  metadata.gz: b9c49a2e0405a8627caee3b7893d3abab9c957698e3b686ee6a590ab56432d70c4365a99e1c9f68a9b2e08554e2600c427af8413562d0aed7d3b328037d13869
-  data.tar.gz: 39239a9bd1ada1fd34b42d8a27f6176d82ea7e986d8e3c2f7a434780ed9dc3d0e4c37a9d8019e49fe43263bd1f89b6650e797e0e7aee645960c887319e29413d
+  metadata.gz: c4e4645899b5b8ef3cf84b4203b911d3cdc3da1cf3f58d67cc1ca8d64b06f95ada184fe7491102c69fd9d75da91346db01f734ad384fcbac492a9169d81238cf
+  data.tar.gz: 72dcab368ce64937c26ed77e89d25face880d71cff3ac9ff5e2797dcdb78023d4d5e6be1a747813426a3851ad6f2a9b9edd7d3bffa9bd4156e8962763b039a48

data/Gemfile.lock

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

data/lib/qiita_org.rb

@@ -40,9 +40,10 @@ module QiitaOrg
     desc "config", "set config"
 
     def config(*argv)
-      option = argv[0] || nil
-      input = [argv[1], argv[2], argv[3]]
-      config =  QiitaConfig.new(option, input)
+      status = argv[0] || "local"
+      option = argv[1] || nil
+      input = [argv[2], argv[3], argv[4]]
+      config =  QiitaConfig.new(status, option, input)
       config.run
     end
 

data/lib/qiita_org/config.rb

@@ -3,10 +3,20 @@ require "fileutils"
 require "json"
 
 class QiitaConfig
-  def initialize(option, input)
+  def initialize(status, option, input)
     @option = option
     @input = input
-    @setup = "#{ENV["HOME"]}/.qiita.conf"
+    if status == "local"
+      search = SearchConfPath.new(Dir.pwd, Dir.home)
+      conf_dir = search.search_conf_path()
+      if conf_dir == Dir.home || @option == "set"
+        @setup = File.join(Dir.pwd, ".qiita.conf")
+      else
+        @setup = File.join(conf_dir, ".qiita.conf")
+      end
+    else
+      @setup = File.join(Dir.home, ".qiita.conf")
+    end
   end
 
   # check qiita.conf or copy qiita.conf
@@ -14,7 +24,7 @@ class QiitaConfig
     lib = File.expand_path("../../../lib", __FILE__)
     cp_file = File.join(lib, "qiita_org", ".qiita.conf")
 
-    if File.exists?("#{ENV["HOME"]}/.qiita.conf")
+    if File.exists?(@setup) # "# {ENV["HOME"]}/.qiita.conf")
       puts @setup.green
       print_config("now", "black")
     else
@@ -46,7 +56,7 @@ class QiitaConfig
   end
 
   def run()
-    if @option == nil
+    if @option == nil || @option == "set"
       check_or_copy_config()
     else
       set_config()

data/lib/qiita_org/get.rb

@@ -3,16 +3,19 @@ require "json"
 require "open-uri"
 require "io/console"
 require "colorize"
+require "qiita_org/search_conf_path.rb"
 
 class QiitaGet
   def initialize(mode, id)
     @mode = mode
     @get_id = id
+    search = SearchConfPath.new(Dir.pwd, Dir.home)
+    @conf_dir = search.search_conf_path()
   end
 
   # set config
   def set_config()
-    conf_path = File.join(ENV["HOME"], ".qiita.conf")
+    conf_path = File.join(@conf_dir, ".qiita.conf")
     conf = JSON.load(File.read(conf_path))
     @access_token = conf["access_token"]
     @teams_url = conf["teams_url"]

data/lib/qiita_org/get_template.rb

@@ -1,9 +1,12 @@
 require "fileutils"
 require "colorize"
+require "qiita_org/search_conf_path"
 
 class QiitaGetTemplate
   def initialize()
     cp_template()
+    search = SearchConfPath.new(Dir.pwd, Dir.home)
+    @conf_dir = search.search_conf_path()
     set_name_and_email()
     # check_write_header()
     check_write_contents()
@@ -83,7 +86,7 @@ class QiitaGetTemplate
   end
 
   def set_name_and_email()
-    conf_path = File.join(ENV["HOME"], ".qiita.conf")
+    conf_path = File.join(@conf_dir, ".qiita.conf")
     conf = JSON.load(File.read(conf_path))
     name = conf["name"]
     email = conf["email"]

data/lib/qiita_org/list.rb

@@ -2,10 +2,13 @@ require "net/https"
 require "json"
 require "open-uri"
 require "colorize"
+require "qiita_org/search_conf_path.rb"
 
 class QiitaList
   def initialize(mode)
     @mode = mode
+    search = SearchConfPath.new(Dir.pwd, Dir.home)
+    @conf_dir = search.search_conf_path()
     set_config()
     select_path()
     access_qiita()
@@ -13,7 +16,7 @@ class QiitaList
   end
 
   def set_config()
-    conf_path = File.join(ENV["HOME"], ".qiita.conf")
+    conf_path = File.join(@conf_dir, ".qiita.conf")
     conf = JSON.load(File.read(conf_path))
     @access_token = conf["access_token"]
     @teams_url = conf["teams_url"]

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

@@ -4,11 +4,15 @@ require "net/https"
 require "json"
 require "command_line/global"
 require "colorize"
+require "qiita_org/search_conf_path.rb"
 
 class QiitaPost
   def initialize(file, option)
     @src = file
     @option = (option == "qiita" || option == "open")? "public" : option
+    search = SearchConfPath.new(Dir.pwd, Dir.home)
+    @conf_dir = search.search_conf_path()
+    p @conf_dir
   end
 
   public
@@ -31,11 +35,12 @@ class QiitaPost
   end
 
   def set_config()
-    conf_path = File.join(ENV["HOME"], ".qiita.conf")
+    conf_path = File.join(@conf_dir, ".qiita.conf")
     @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
@@ -65,8 +70,9 @@ class QiitaPost
   end
 
   def select_option(option)
-    qiita = (option == "teams")? "https://nishitani.qiita.com/" :
-      "https://qiita.com/"
+    qiita = (option == "teams")? @teams_url : "https://qiita.com/"
+    #qiita = (option == "teams")? "https://nishitani.qiita.com/" :
+     # "https://qiita.com/"
     case option
     when "teams", "qiita", "public", "open"
       private = false

data/lib/qiita_org/search_conf_path.rb

@@ -0,0 +1,18 @@
+class SearchConfPath
+  def initialize(dir, home)
+    @dir = dir
+    @home = home
+    search_conf_path()
+  end
+
+  def search_conf_path()
+    while @dir != @home
+      if File.exists?(File.join(@dir, ".qiita.conf"))
+        return @dir
+      else
+        @dir = @dir.match(/(.+)\//)[1]
+      end
+    end
+    return @dir
+  end
+end

data/lib/qiita_org/version.rb

@@ -1,3 +1,3 @@
 module QiitaOrg
-  VERSION = "0.1.4"
+  VERSION = "0.1.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qiita_org
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.9
 platform: ruby
 authors:
 - Kenta Yamamoto
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-16 00:00:00.000000000 Z
+date: 2020-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -959,7 +959,9 @@ files:
 - 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
 - lib/qiita_org/version.rb
 - qiita_org.gemspec
@@ -967,7 +969,7 @@ homepage: https://github.com/yamatoken/qiita_org
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -983,7 +985,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: []