pirka 0.1.0

data/app/update.rb

@@ -0,0 +1,67 @@
+require "English"
+require "pathname"
+require "uri"
+require "pirka/library"
+require_relative "subcommand"
+
+module Pirka
+  class App
+    class Update
+      PROGRAM_NAME = "update"
+      DESCRIPTION = "Update library files by remote files"
+
+      include Subcommand
+
+      URI = ::URI.parse("https://gitlab.com/KitaitiMakoto/pirka-library.git")
+
+      def run(argv)
+        parse_options! argv
+        ensure_git_command
+        dir = determine_directory(URI)
+        if dir.directory?
+          update_repository(URI, dir)
+        else
+          clone_repository(URI, dir)
+          $stderr.puts "Library was cloned to:"
+          $stdout.puts dir
+          @config.additional_directories << dir
+          @config.library_repositories << URI
+          begin
+            @config.save
+            $stderr.puts "and added to config file #{@config.filepath.to_s.dump}"
+          rescue Errno::EACCESS => error
+            $stderr.puts "Couldn't save config file to #{@config.filepath.to_s.dump}"
+            $stderr.puts error
+          end
+        end
+      end
+
+      def ensure_git_command
+        raise "Cannot find `git` command" unless system("type", "git")
+      end
+
+      # @todo Make more generic
+      def determine_directory(uri)
+        (Pathname.new(Dir.home)/".local/share/pirka"/uri.host/uri.path[1..-1]).sub_ext("")
+      end
+
+      def clone_repository(uri, dir)
+        run_command "git clone #{uri} #{dir}"
+      end
+
+      # @todo Make more generic
+      def update_repository(uri, dir)
+        Dir.chdir dir do
+          run_command "git fetch origin master && git checkout origin/master"
+        end
+      end
+
+      def run_command(command)
+        output = `#{command}`
+        $stderr.puts "Executing \`#{command}\`"
+        raise "Failed to execute \`#{command}\`" unless $CHILD_STATUS.success?
+        output
+      end
+    end
+  end
+end

data/app.rb

@@ -0,0 +1,74 @@
+require "optparse"
+require "pirka/version"
+require "pirka/config"
+
+gem "epub-parser", Pirka::EPUB_PARSER_VERSION
+
+module Pirka
+  class App
+    DESCRIPTION = "Pirka highlights source code syntax in EPUB files"
+    APPS = {}
+
+    def initialize
+      @config = nil
+      @tmp_opts = {
+        "additional_directories" => []
+      }
+    end
+
+    def run(argv)
+      parse_options! argv
+      app = APPS[argv.first] ? APPS[argv.shift] : Highlight
+      app.new(@config).run(argv)
+    end
+
+    private
+
+    def parse_options!(argv)
+      config_path = Config.filepath
+
+      parser = OptionParser.new {|opt|
+        opt.version = Pirka::VERSION
+
+        opt.banner = <<EOB
+#{DESCRIPTION}
+
+Usage: #{opt.program_name} [global options] [<command>] [options]
+EOB
+
+        opt.separator ""
+        opt.separator "Global options:"
+        opt.on "-c", "--config=FILE", "Config file. Defaults to #{Config.filepath}", Pathname do |path|
+          config_path = path
+        end
+        opt.on "-s", "--data-home=DIRECTORY", "Directory to *SAVE* library data", Pathname do |path|
+          @tmp_opts["data_home"] = path
+        end
+        opt.on "-d", "--directory=DIRECTORY", "Directory to *SEARCH* library data.", "Specify multiple times to add multiple directories.", Pathname do |path|
+          @tmp_opts["additional_directories"] << path
+        end
+
+        opt.separator ""
+        opt.separator "Commands:"
+        width = APPS.keys.collect(&:length).max
+        APPS.each_pair do |command, app|
+          opt.separator opt.summary_indent + command.ljust(width) +
+                        opt.summary_indent * 2 + app::DESCRIPTION
+        end
+        opt.separator "If command is ommitted, highlight is used with no option"
+      }
+      parser.order! argv
+      @config = config_path.file? ? Config.load_file(config_path) : Config.new
+      @config.data_home = @tmp_opts["data_home"] if @tmp_opts["data_home"]
+      @config.additional_directories = @tmp_opts["additional_directories"] unless @tmp_opts["additional_directories"].empty?
+
+      Library.data_home = @config.data_home
+      Library.additional_directories = @config.additional_directories
+    end
+  end
+end
+
+require_relative "app/highlight"
+require_relative "app/detect"
+require_relative "app/update"
+require_relative "app/lib"

data/bin/pirka

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require_relative "../app"
+
+root = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+if File.directory?(File.join(root,'.git'))
+  Dir.chdir(root) do
+    begin
+      require 'bundler/setup'
+    rescue LoadError => e
+      warn e.message
+      warn "Run `gem install bundler` to install Bundler"
+      exit -1
+    end
+  end
+end
+
+Pirka::App.new.run(ARGV)

data/lib/pirka/config.rb

@@ -0,0 +1,110 @@
+require "pathname"
+require "yaml"
+require "pirka/library"
+
+module Pirka
+  class Config
+    FILE_NAME = "pirka.yaml"
+    XDG_CONFIG_HOME = Pathname.new(".config")
+    CONFIG_FILE= XDG_CONFIG_HOME/FILE_NAME
+    XDG_CONFIG_DIRS = [Pathname.new("/etc/xdg")]
+    CONFIG_DIRS = XDG_CONFIG_DIRS.collect {|dir| dir/FILE_NAME}
+
+    @config_home = nil
+    @additional_directories = []
+
+    class << self
+      attr_accessor :config_home, :additional_directories
+
+      def directories(user = nil)
+        config_dirs = ENV["XDG_CONFIG_DIRS"] ?
+                        ENX["XDG_CONFIG_DIR"].split(":").collect {|dir| Pathname.new(dir)} :
+                        CONFIG_DIRS
+        config_home = ENV["XDG_CONFIG_HOME"] ?
+                        Pathname.new(ENV["XDG_CONFIG_HOME"]) :
+                        Pathname.new(Dir.home(user))/XDG_CONFIG_HOME
+        ([@config_home, config_home] + @additional_directories + config_dirs).compact
+      end
+
+      def config_directory(user = nil)
+        directories.first
+      end
+
+      def load_file(path)
+        load_hash(
+          YAML.load_file(path).each_with_object({}) {|(key, value), h|
+            h[key] = case key
+                     when "data_home"
+                       Pathname(value)
+                     when "additional_directories"
+                       value.collect {|val| Pathname(val)}
+                     when "library_repositories"
+                       value.collect {|val| URI(val)}
+                     else
+                       value
+                     end
+          })
+      end
+
+      def load_hash(h)
+        config = new
+        %w[data_home additional_directories library_repositories].each do |attr|
+          config.__send__("#{attr}=", h[attr]) if h[attr]
+        end
+        config
+      end
+
+      def filepath
+        config_directory/FILE_NAME
+      end
+    end
+
+    attr_accessor :data_home, :additional_directories, :library_repositories
+
+    # @todo Consider login user
+    def initialize
+      @data_home = nil
+      @additional_directories = []
+      @library_repositories = []
+    end
+
+    # @todo Consider login user
+    def path_from_repository(repository_uri)
+      Library.data_directory/dirname_from_repository(repository_uri)
+    end
+
+    # @todo Consider URIs other than Git HTTPS URI
+    def dirname_from_repository(repository_uri)
+      repository_uri.host/repository_uri.path[1..-1].sub_ext("")
+    end
+
+    def config_directory(user = nil)
+      self.class.config_directory(user)
+    end
+
+    def filepath
+      self.class.filepath
+    end
+
+    def save(path = nil)
+      path = Pathname(path || filepath)
+      path.dirname.mkpath unless path.dirname.directory?
+      path.write to_yaml
+      path
+    end
+
+    def to_h
+      h = {}
+      h["data_home"] = @data_home.to_path if @data_home
+      %w[additional_directories library_repositories].each do |key|
+        value = __send__(key)
+        h[key] = value.collect(&:to_s) unless value.empty?
+      end
+      h
+    end
+
+    def to_yaml
+      to_h.to_yaml
+    end
+  end
+end

data/lib/pirka/library.rb

@@ -0,0 +1,152 @@
+require "pathname"
+require "base64"
+require "yaml"
+require "epub/parser/cfi"
+
+module Pirka
+  # Environment variables affect this class:
+  #   XDG_DATA_HOME: Directory to store library files and read. Defaults to $HOME/.local/share
+  #   XDG_DATA_DIRS: Directories to search library files. Separated with a colon ':'. Defaults to /usr/local/share:/usr/share
+  # 
+  # @see https://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+  class Library
+    DIR_NAME = "pirka/local"
+    EXT = ".yaml"
+    SUBDIR_LENGTH = 4
+    XDG_DATA_HOME = Pathname.new(".local/share")
+    DATA_HOME = XDG_DATA_HOME/DIR_NAME
+    XDG_DATA_DIRS = [Pathname.new("/usr/local/share"), Pathname.new("/usr/share")]
+    DATA_DIRS = XDG_DATA_DIRS.collect {|dir| dir/DIR_NAME}
+
+    @data_home = nil
+    @additional_directories = []
+
+    class << self
+      attr_accessor :data_home, :additional_directories
+
+      # @return [Array<Pathname>]
+      def directories(user = nil)
+        data_dirs = ENV["XDG_DATA_DIRS"] ?
+                      ENV["XDG_DATA_DIRS"].split(":").collect {|dir| Pathname.new(dir)/DIR_NAME} :
+                      DATA_DIRS
+        data_home = ENV["XDG_DATA_HOME"] ?
+                      Pathname.new(ENV["XDG_DATA_HOME"])/DIR_NAME :
+                      Pathname.new(Dir.home(user))/DATA_HOME
+        ([@data_home, data_home] + @additional_directories + data_dirs).compact
+      end
+
+      # @see https://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+      def data_directory(user = nil)
+        directories.first
+      end
+
+      # @param [String] release_identifier
+      # @return [Library, nil]
+      def find_by_release_identifier(release_identifier)
+        lib_path = filename(release_identifier)
+        directories.each do |dir|
+          path = dir/lib_path
+          return load_file(path) if path.file?
+        end
+        nil
+      end
+
+      # @param [String] release_identifier Release Identifier
+      # @return [String] String that `Release Identifier` property in metadata is encoded based on RFC 4648 "Base 64 Encoding with URL and Filename Safe Alphabet"
+      # @see https://tools.ietf.org/html/rfc4648#page-7
+      # @todo Better name
+      def basename_without_ext(release_identifier)
+        Base64.urlsafe_encode64(release_identifier)
+      end
+
+      def filename(release_identifier)
+        name = basename_without_ext(release_identifier)
+        name.insert(SUBDIR_LENGTH, "/") if name.length > SUBDIR_LENGTH
+        name + EXT
+      end
+
+      # @param [Pathname, String] path
+      # @return [Library]
+      def load_file(path)
+        load_hash(YAML.load_file(path.to_s))
+      end
+
+      # @param [Hash] h
+      # @return [Library]
+      def load_hash(h)
+        library = new
+
+        h.each_pair do |key, value|
+          if key == "codelist"
+            value.each_pair do |cfi, data|
+              library.codelist[EPUB::Parser::CFI.parse(cfi)] = data
+            end
+          else
+            library.metadata[key] = value
+          end
+        end
+
+        library
+      end
+    end
+
+    attr_reader :metadata, :codelist
+
+    # @param [Pathname, String, nil] directory for library files. When `nil` passed, default directories are used
+    def initialize
+      @metadata = {}
+      @codelist = {}
+    end
+
+    def data_directory(user = nil)
+      self.class.data_directory(user)
+    end
+
+    def filename
+      raise "Release Identifier is not set" unless @metadata["Release Identifier"]
+      self.class.filename(@metadata["Release Identifier"])
+    end
+
+    # @param [Pathname, String, nil] path File path to save library data.
+    #   When `nil` is passwd, default directory + filename determined by Release Identifier is used
+    # @return [Pathname] File path that library data was saved
+    def save(path = nil)
+      path = data_directory/filename unless path
+      path = Pathname(path)
+      path.dirname.mkpath unless path.dirname.directory?
+      path.write to_yaml
+      path
+    end
+
+    # Iterate over codelist in order of EPUB CFI
+    # @overload each
+    #   @yieldparam [EPUB::CFI] cfi EPUB CFI indicating code element
+    #   @yieldparam [String] language Language name
+    # @overload each
+    #   @return [Enumerator] Enumerator which iterates over cfi and lang
+    def each
+      sorted_list = @codelist.each_pair.sort_by {|(cfi, lang)| cfi}
+      if block_given?
+        sorted_list.each do |(cfi, lang)|
+          yield cfi, lang
+        end
+      else
+        sorted_list.each
+      end
+    end
+
+    # @return [Hash]
+    def to_h
+      metadata.merge({
+        "codelist" => each.with_object({}) {|(cfi, value), list|
+          list[cfi.to_fragment] = value
+        }
+      })
+    end
+
+    # @return [String]
+    def to_yaml
+      to_h.to_yaml
+    end
+  end
+end

data/lib/pirka/version.rb

@@ -0,0 +1,22 @@
+#
+# Copyright (c) 2017 KITAITI Makoto (KitaitiMakoto at gmail.com)
+#
+# pirka 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.
+#
+# pirka 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 pirka.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+module Pirka
+  # pirka version
+  VERSION = "0.1.0"
+  EPUB_PARSER_VERSION = "0.3.1"
+end

data/lib/pirka.rb

@@ -0,0 +1 @@
+require 'pirka/version'

data/pirka.gemspec

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pirka/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pirka"
+  gem.version       = Pirka::VERSION
+  gem.summary       = %q{Syntax highlighting tool for EPUB books}
+  gem.description   = %q{Pirka highlights source code syntax in EPUB books}
+  gem.license       = "GPL"
+  gem.authors       = ["KITAITI Makoto"]
+  gem.email         = "KitaitiMakoto@gmail.com"
+  gem.homepage      = "https://gitlab.com/KitaitiMakoto/pirka"
+
+  gem.files         = `git ls-files`.split($/)
+
+  `git submodule --quiet foreach --recursive pwd`.split($/).each do |submodule|
+    submodule.sub!("#{Dir.pwd}/",'')
+
+    Dir.chdir(submodule) do
+      `git ls-files`.split($/).map do |subpath|
+        gem.files << File.join(submodule,subpath)
+      end
+    end
+  end
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'epub-parser', Pirka::EPUB_PARSER_VERSION
+  gem.add_runtime_dependency 'epub-maker'
+  gem.add_runtime_dependency 'rouge'
+  gem.add_runtime_dependency 'rouge-lexers-fluentd'
+  gem.add_runtime_dependency 'optparse-pathname'
+  gem.add_runtime_dependency 'colored'
+
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'test-unit'
+  gem.add_development_dependency 'test-unit-notify'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'rubygems-tasks'
+  gem.add_development_dependency 'yard'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'pry-doc'
+  gem.add_development_dependency 'zipruby'
+end

data/test/fixtures/YWJj.yaml

@@ -0,0 +1,10 @@
+---
+Release Identifier: abc
+title: abc
+codelist:
+  epubcfi(/6/30!/4/2/56/2):
+    language: nginx
+  epubcfi(/6/30!/4/2/58/2):
+    language: nginx
+  epubcfi(/6/31!/4/2/56/2):
+    language: nginx

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+
+begin
+  require 'bundler/setup'
+rescue LoadError => error
+  abort error.message
+end
+
+require "simplecov"
+SimpleCov.start do
+  add_filter "/test"
+end
+
+require 'test/unit'
+require "test/unit/notify"
+
+class Test::Unit::TestCase
+end

data/test/test_library.rb

@@ -0,0 +1,152 @@
+require "helper"
+require "yaml"
+require "tmpdir"
+require "pirka/library"
+require "epub/parser/cfi"
+
+class TestLibrary < Test::Unit::TestCase
+  def setup
+    Pirka::Library.data_home = nil
+    Pirka::Library.additional_directories.clear
+    @library = Pirka::Library.new
+    @library.metadata["Release Identifier"] = "abc"
+    @library.metadata["title"] = "abc"
+    @library.codelist[EPUB::CFI("/6/30!/4/2/58/2")] = {"language" => "nginx"}
+    @library.codelist[EPUB::CFI("/6/31!/4/2/56/2")] = {"language" => "nginx"}
+    @library.codelist[EPUB::CFI("/6/30!/4/2/56/2")] = {"language" => "nginx"}
+    @fixure_path = "test/fixtures/YWJj.yaml"
+    @yaml = <<EOY
+---
+Release Identifier: abc
+title: abc
+codelist:
+  epubcfi(/6/30!/4/2/56/2):
+    language: nginx
+  epubcfi(/6/30!/4/2/58/2):
+    language: nginx
+  epubcfi(/6/31!/4/2/56/2):
+    language: nginx
+EOY
+  end
+
+  def test_load_hash
+    actual = Pirka::Library.load_hash(YAML.load(@yaml))
+    assert_equal @library.metadata, actual.metadata
+    assert_equal @library.each.to_a, actual.each.to_a
+  end
+
+  def test_load_file
+    actual = Pirka::Library.load_file(@fixure_path)
+    assert_equal @library.metadata, actual.metadata
+    assert_equal @library.each.to_a, actual.each.to_a
+  end
+
+  def test_each_iterates_over_list_in_order_of_cfi
+    cfis = %w[/6/30!/4/2/56/2
+              /6/30!/4/2/58/2
+              /6/31!/4/2/56/2]
+    i = 0
+    @library.each do |(cfi, _)|
+      assert_equal cfi.to_s, cfis[i]
+      i += 1
+    end
+  end
+
+  def test_each_returns_enumerator
+    assert_equal %w[/6/30!/4/2/56/2
+                    /6/30!/4/2/58/2
+                    /6/31!/4/2/56/2],
+                 @library.each.collect {|(cfi, _)| cfi.to_s}
+  end
+
+  def test_to_yaml
+    expected = YAML.load(@yaml)
+    actual = YAML.load(@library.to_yaml)
+    assert_equal expected, actual
+  end
+
+  def test_save_to_path_when_path_specified
+    Dir.mktmpdir "pirka" do |dir|
+      path = Pathname.new(dir)/"arbitral-filename.yaml"
+      @library.save(path)
+      data = YAML.load_file(path.to_path)
+      codelist = data.delete("codelist")
+      assert_equal @library.metadata, data
+
+      expected_codelist = @library.each.with_object({}) {|(cfi, value), list|
+        list[cfi.to_fragment] = value
+      }
+      assert_equal expected_codelist, codelist
+    end
+  end
+
+  def test_save_to_default_directory_when_path_not_specified
+    Dir.mktmpdir "pirka" do |dir|
+      xdh = ENV["XDG_DATA_HOME"]
+      begin
+        ENV["XDG_DATA_HOME"] = dir
+        @library.save
+      ensure
+        ENV["XDG_DATA_HOME"] = xdh
+      end
+      path = Pathname.new(dir)/"pirka/local/YWJj.yaml"
+      assert_path_exist path
+
+      data = YAML.load_file(path)
+      codelist = data.delete("codelist")
+      assert_equal @library.metadata, data
+
+      expected_codelist = @library.each.with_object({}) {|(cfi, value), list|
+        list[cfi.to_fragment] = value
+      }
+      assert_equal expected_codelist, codelist
+    end
+  end
+
+  def test_save_to_specified_directory_when_data_home_is_specified
+    Dir.mktmpdir "pirka" do |dir|
+      Pirka::Library.data_home = Pathname.new(dir)
+      library = Pirka::Library.new
+      library.metadata["Release Identifier"] = "abc"
+      library.metadata["title"] = "abc"
+      library.codelist[EPUB::CFI("/6/30!/4/2/58/2")] = {"language" => "nginx"}
+      library.codelist[EPUB::CFI("/6/31!/4/2/56/2")] = {"language" => "nginx"}
+      library.codelist[EPUB::CFI("/6/30!/4/2/56/2")] = {"language" => "nginx"}
+
+      library.save
+
+      path = Pathname.new("#{dir}/YWJj.yaml")
+      assert_path_exist path.to_path
+      assert_equal @yaml, path.read
+    end
+  end
+
+  def test_save_makes_subdirectory_when_basename_is_longer_than_4_characters
+    Dir.mktmpdir "pirka" do |dir|
+      Pirka::Library.data_home = Pathname.new(dir)
+      library = Pirka::Library.new
+      library.metadata["Release Identifier"] = "abcd"
+
+      library.save
+      path = Pathname.new(dir)/"YWJj/ZA==.yaml"
+      assert_path_exist path
+    end
+  end
+
+  def test_find_by_release_identifier
+    Dir.mktmpdir "pirka" do |dir|
+      path = Pathname.new(dir)/"pirka/local/YWJj.yaml"
+      path.dirname.mkpath
+      path.write(@yaml)
+      xdh = ENV["XDG_DATA_HOME"]
+      begin
+        ENV["XDG_DATA_HOME"] = dir
+        library = Pirka::Library.find_by_release_identifier("abc")
+      ensure
+        ENV["XDG_DATA_HOME"] = xdh
+      end
+      assert_equal @library.metadata, library.metadata
+      assert_equal @library.each.to_a, library.each.to_a
+    end
+  end
+end

data/test/test_pirka.rb

@@ -0,0 +1,12 @@
+require 'helper'
+require 'pirka'
+
+class TestPirka < Test::Unit::TestCase
+
+  def test_version
+    version = Pirka.const_get('VERSION')
+
+    assert !version.empty?, 'should have a VERSION constant'
+  end
+
+end