img_to_pdf 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5dde70fccbb8aca8711e4ba1b6542fd1e1b7e6a9a95d86366adba0c10edb00e1
+  data.tar.gz: c84bba32cd8bb79d6656853045ff3a5f2654b57072c656ad545a3e62e5f26117
+SHA512:
+  metadata.gz: d24a1be432c7f643ba5b6253deb239cd81e8fc94a77d458e312a46834a1b11b3e2e2f92add210b7aab90862be63cb8ada194b9ca5c05bac1422eec3f6eac1533
+  data.tar.gz: 4d9213f55e4417485266ade0c7deabd5053dcf9bda9f0e39094a8004635ed5dfacbaffaafc523cecfe667e527601d5f70376394ed48365165bdfe47504c2f43c

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2020 Yuya.Nishida.
+
+X11 License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# img_to_pdf
+
+A tool to create PDF from raster image.
+
+[![License X11](https://img.shields.io/badge/license-X11-brightgreen.svg)](https://raw.githubusercontent.com/nishidayuya/img_to_pdf/master/LICENSE.txt)
+
+## Requirements
+
+* Ruby
+* ImageMagick
+
+## Installation
+
+```sh
+$ gem install img_to_pdf
+```
+
+## Usage
+
+Create PDF from PNG:
+
+```sh
+$ img_to_pdf input.png output.pdf
+```
+
+Same as:
+
+```sh
+$ img_to_pdf \
+    --paper-size=a4-landscape \
+    --horizontal-pages=1 \
+    --vertical-pages=1 \
+    input.png output.pdf
+```
+
+Create 3x4 pages B5 portrait PDF from JPG:
+
+```
+$ img_to_pdf \
+    --paper-size=b5-portrait \
+    --horizontal-pages=3 \
+    --vertical-pages=4 \
+    input.jpg output.pdf
+```
+
+Show help message:
+
+```
+$ img_to_pdf --help
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nishidayuya/img_to_pdf .

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task(default: %i[test])

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "img_to_pdf"
+
+# 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(__FILE__)

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/exe/img_to_pdf

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "img_to_pdf"
+
+ImgToPdf::Cli.run(ARGV)

data/img_to_pdf.gemspec

@@ -0,0 +1,35 @@
+require "pathname"
+
+require_relative 'lib/img_to_pdf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "img_to_pdf"
+  spec.version       = ImgToPdf::VERSION
+  spec.authors       = ["Yuya.Nishida."]
+  spec.email         = ["yuya@j96.org"]
+
+  spec.summary       = (Pathname(__dir__) / "README.md").each_line(chomp: true).
+                         lazy.grep_v(/\A\s*\z|\A\#/).first
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/nishidayuya/" + spec.name
+  spec.license       = "X11"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "prawn"
+  spec.add_runtime_dependency "mini_magick"
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit"
+end

data/lib/img_to_pdf.rb

@@ -0,0 +1,15 @@
+require "pathname"
+
+module ImgToPdf
+  autoload(:VERSION, "img_to_pdf/version")
+
+  # set autoload
+  lib_path = Pathname(__dir__)
+  Pathname.glob(lib_path / "img_to_pdf/*.rb").sort.each do |path|
+    no_ext_path = path.relative_path_from(lib_path).sub_ext("")
+    class_name = no_ext_path.basename.to_s.
+                   split("_").map(&:capitalize).join.to_sym
+    next if class_name == :Version
+    autoload(class_name, no_ext_path.to_s)
+  end
+end

data/lib/img_to_pdf/cli.rb

@@ -0,0 +1,25 @@
+require "tmpdir"
+
+require "img_to_pdf"
+
+module ImgToPdf::Cli
+  extend self
+
+  def run(argv)
+    option = ImgToPdf::CliOption.from_argv(argv)
+    page_dimension_pt = ImgToPdf::PaperSizeParser.(option.paper_size_text)
+    input_image = ImgToPdf::Image.from_path(option.input_path)
+    document = ImgToPdf::FitPageDocument.create(
+      page_dimension_pt: page_dimension_pt,
+      margin_pt: option.margin_pt,
+      n_horizontal_pages: option.n_horizontal_pages,
+      n_vertical_pages: option.n_vertical_pages,
+      image: input_image,
+    )
+    document.render_file(option.output_path)
+  rescue ImgToPdf::Error => e
+    raise if option.debug
+    STDERR.puts("#{e.class.name}: #{e.message}")
+    exit(1)
+  end
+end

data/lib/img_to_pdf/cli_option.rb

@@ -0,0 +1,68 @@
+require "optparse"
+
+require "img_to_pdf"
+
+class ImgToPdf::CliOption < Struct.new(:input_path, :output_path, :debug,
+                                         :paper_size_text, :margin_pt,
+                                         :n_horizontal_pages, :n_vertical_pages,
+                                         keyword_init: true)
+  BANNER = <<EOS.chomp
+Usage: #{File.basename(Process.argv0)} [options] input_image_path output_pdf_path
+EOS
+
+  class << self
+    def default
+      default_margin_pt = ImgToPdf::Unit.convert_mm_to_pt(10)
+      return new(
+               input_path: nil,
+               output_path: nil,
+               debug: false,
+               paper_size_text: "a4-landscape",
+               margin_pt: ImgToPdf::Margin.new(
+                 left: default_margin_pt,
+                 right: default_margin_pt,
+                 top: default_margin_pt,
+                 bottom: default_margin_pt,
+               ),
+               n_horizontal_pages: 1,
+               n_vertical_pages: 1,
+             )
+    end
+
+    def from_argv(argv, stdout: STDOUT)
+      result = default
+
+      parser = OptionParser.new
+      parser.version = ImgToPdf::VERSION
+      parser.banner = BANNER
+      parser.summary_indent = ""
+      parser.separator("")
+      parser.separator("Options:")
+      parser.on("--paper-size=SIZE",
+                "specify paper size. 'a4-landscape'(default), 'b3-portrait', etc.") do |v|
+        result.paper_size_text = v
+      end
+      parser.on("--horizontal-pages=INTEGER",
+                "specify number of horizontal pages. default 1.") do |v|
+        result.n_horizontal_pages = ImgToPdf::IntegerParser.(v)
+      end
+      parser.on("--vertical-pages=INTEGER",
+                "specify number of vertical pages. default 1.") do |v|
+        result.n_vertical_pages = ImgToPdf::IntegerParser.(v)
+      end
+      parser.on("--debug") do
+        result.debug = true
+      end
+
+      input_path, output_path = *parser.parse(argv)
+      if !output_path
+        stdout.puts(parser.help)
+        exit(1)
+      end
+      result.input_path = Pathname(input_path).expand_path
+      result.output_path = Pathname(output_path).expand_path
+
+      return result
+    end
+  end
+end

data/lib/img_to_pdf/dimension.rb

@@ -0,0 +1,40 @@
+require "img_to_pdf"
+
+class ImgToPdf::Dimension < Struct.new(:width, :height, keyword_init: true)
+  class << self
+    # @param [Array<(Float, Float)>] ary `[width, height]`.
+    # @return ImgToPdf::Dimension parsed.
+    def from_array(ary)
+      return new(width: ary[0], height: ary[1])
+    end
+  end
+
+  # @return [Array<(Float, Float)>] array. `[width, height]`.
+  def to_a
+    return [width, height]
+  end
+
+  # @return [:landscape, :portrait] direction of dimension.
+  def direction
+    return width > height ? :landscape : :portrait
+  end
+
+  # @return [ImgToPdf::Dimension] transposed dimension.
+  def transpose
+    return self.class.new(width: height, height: width)
+  end
+
+  # @param [:landscape, :portrait] direction
+  # @return [ImgToPdf::Dimension] justified dimension.
+  def justify_direction(target_direction)
+    return direction == target_direction ? dup : transpose
+  end
+
+  # points to inches.
+  #
+  # @return [ImgToPdf::Dimension] inch dimension.
+  def pt_to_in
+    return self.class.new(width: ImgToPdf::Unit.convert_pt_to_in(width),
+                          height: ImgToPdf::Unit.convert_pt_to_in(height))
+  end
+end

data/lib/img_to_pdf/error.rb

@@ -0,0 +1,2 @@
+class ImgToPdf::Error < StandardError
+end

data/lib/img_to_pdf/fit_page_document.rb

@@ -0,0 +1,92 @@
+require "prawn"
+
+require "img_to_pdf"
+
+class ImgToPdf::FitPageDocument
+  # @param [ImgToPdf::Dimension] page_dimension_pt page size. points.
+  # @param [ImgToPdf::Margin] margin_pt margin size. points.
+  # @param [ImgToPdf::Image] image source image.
+  # @param [Integer] n_horizontal_pages number of horizontal pages.
+  # @param [Integer] n_vertical_pages number of vertical pages.
+  # @return [ImgToPdf::FitPageDocument] document to render PDF.
+  def self.create(page_dimension_pt:, margin_pt:, image:,
+                  n_horizontal_pages: 1, n_vertical_pages: 1)
+    result = new(page_dimension_pt: page_dimension_pt, margin_pt: margin_pt,
+                 n_horizontal_pages: n_horizontal_pages,
+                 n_vertical_pages: n_vertical_pages,
+                 image: image)
+    result.draw
+    return result
+  end
+
+  def initialize(page_dimension_pt:, margin_pt:, image:,
+                 n_horizontal_pages:, n_vertical_pages:)
+    @page_dimension_pt = page_dimension_pt
+    @margin_pt = margin_pt
+    @image = image
+    @n_horizontal_pages = n_horizontal_pages
+    @n_vertical_pages = n_vertical_pages
+
+    @pdf = Prawn::Document.new(
+      page_size: @page_dimension_pt.to_a,
+      margin: @margin_pt.to_a,
+      skip_page_creation: true,
+      info: {
+        Creator: "img_to_pdf version #{ImgToPdf::VERSION}",
+      },
+    )
+  end
+
+  def draw
+    canvas_dimension_pt = determine_canvas_dimension_pt
+    canvas_scale = determine_canvas_scale(canvas_dimension_pt)
+    sub_image_dimension_px = ImgToPdf::Dimension.new(
+      width: @image.dimension_px.width / @n_horizontal_pages,
+      height: @image.dimension_px.height / @n_vertical_pages,
+    )
+    each_sub_image(sub_image_dimension_px) do |sub_image|
+      @pdf.start_new_page
+      @pdf.image(
+        sub_image.path,
+        scale: canvas_scale,
+        at: [0, canvas_dimension_pt.height / @n_vertical_pages],
+      )
+    end
+  end
+
+  # @param [Pathname] output_path path to PDF output.
+  def render_file(output_path)
+    @pdf.render_file(output_path)
+  end
+
+  private
+
+  def determine_canvas_dimension_pt
+    w = (@page_dimension_pt.width - @margin_pt.left - @margin_pt.right) *
+        @n_horizontal_pages
+    h = (@page_dimension_pt.height - @margin_pt.top - @margin_pt.bottom) *
+        @n_vertical_pages
+    return ImgToPdf::Dimension.new(width: w, height: h)
+  end
+
+  def determine_canvas_scale(canvas_dimension_pt)
+    canvas_dimension_in = canvas_dimension_pt.pt_to_in
+    dpi_from_width = @image.dimension_px.width / canvas_dimension_in.width
+    dpi_from_height = @image.dimension_px.height / canvas_dimension_in.height
+    canvas_dpi = [dpi_from_width, dpi_from_height].max
+    return 72 / canvas_dpi
+  end
+
+  def each_sub_image(sub_image_dimension_px)
+    @n_vertical_pages.times do |i_y|
+      @n_horizontal_pages.times do |i_x|
+        @image.crop(sub_image_dimension_px.width * i_x,
+                    sub_image_dimension_px.height * i_y,
+                    sub_image_dimension_px.width,
+                    sub_image_dimension_px.height) do |sub_image|
+          yield(sub_image)
+        end
+      end
+    end
+  end
+end

data/lib/img_to_pdf/image.rb

@@ -0,0 +1,52 @@
+require "tempfile"
+
+require "mini_magick"
+require "prawn"
+
+require "img_to_pdf"
+
+class ImgToPdf::Image
+  attr_reader :path
+
+  class << self
+    # @param [Pathname] path path to instantiate.
+    # @return [ImgToPdf::Image] instance.
+    def from_path(path)
+      return new(path)
+    end
+  end
+
+  def initialize(path)
+    @dimension_px = nil
+    @path = path
+  end
+
+  # @return [ImgToPdf::Dimension] image dimension. pixels.
+  def dimension_px
+    return @dimension_px if @dimension_px
+    image_klass = Prawn::Images.const_get(path.extname.upcase.sub(/\A\./, ""))
+    image = image_klass.new(path.read)
+    @dimension_px = ImgToPdf::Dimension.new(width: image.width,
+                                              height: image.height)
+    return @dimension_px
+  end
+
+  # @param [Numeric] x
+  # @param [Numeric] y
+  # @param [Numeric] width
+  # @param [Numeric] height
+  # @yieldparam [ImgToPdf::Image] sub_image cropped sub image.
+  def crop(x, y, width, height)
+    Tempfile.create(["img_to_pdf-image-", path.extname]) do |f|
+      f.close
+      sub_raw_image_path = Pathname(f.path)
+
+      raw_image = MiniMagick::Image.open(path)
+      raw_image.crop("#{width}x#{height}+#{x}+#{y}")
+      raw_image.write(sub_raw_image_path)
+
+      sub_image = self.class.from_path(sub_raw_image_path)
+      yield(sub_image)
+    end
+  end
+end

data/lib/img_to_pdf/integer_parser.rb

@@ -0,0 +1,12 @@
+require "img_to_pdf"
+
+module ImgToPdf::IntegerParser
+  extend self
+
+  def call(s)
+    md = /\A\d+\z/.match(s)
+    raise ImgToPdf::ParserError, "invalid integer: #{s.inspect}" if !md
+
+    return s.to_i
+  end
+end

data/lib/img_to_pdf/margin.rb

@@ -0,0 +1,5 @@
+require "img_to_pdf"
+
+class ImgToPdf::Margin < Struct.new(:top, :right, :bottom, :left,
+                                      keyword_init: true)
+end

data/lib/img_to_pdf/paper_size_parser.rb

@@ -0,0 +1,28 @@
+require "pdf/core/page_geometry"
+
+require "img_to_pdf"
+
+module ImgToPdf::PaperSizeParser
+  extend self
+
+  AVAILABLE_DIRECTIONS = %i[landscape portrait]
+
+  # @param [String] s paper size text. "a4-landscape", "b3-portrait", etc.
+  # @return [ImgToPdf::Dimension] parsed paper dimension. points.
+  def call(s)
+    paper_size, direction = *s.split("-")
+    direction = direction.downcase.to_sym
+    if !AVAILABLE_DIRECTIONS.include?(direction)
+      raise ImgToPdf::ParserError, "invalid paper direction: #{s.inspect}"
+    end
+    raw_size_pt = PDF::Core::PageGeometry::SIZES[paper_size.upcase]
+    if !raw_size_pt
+      raise ImgToPdf::ParserError, "invalid paper size: #{s.inspect}"
+    end
+
+    paper_dimension_pt = ImgToPdf::Dimension.from_array(raw_size_pt)
+    paper_dimension_pt = paper_dimension_pt.justify_direction(direction)
+
+    return paper_dimension_pt
+  end
+end

data/lib/img_to_pdf/parser_error.rb

@@ -0,0 +1,4 @@
+require "img_to_pdf"
+
+class ImgToPdf::ParserError < ImgToPdf::Error
+end

data/lib/img_to_pdf/unit.rb

@@ -0,0 +1,17 @@
+require "img_to_pdf"
+
+module ImgToPdf::Unit
+  extend self
+
+  # @param [Float] mm source length. millimeters.
+  # @return [Float] destination length. points.
+  def convert_mm_to_pt(mm)
+    return mm / 25.4 * 72
+  end
+
+  # @param [Float] pt source length. points.
+  # @return [Float] destination length. inches.
+  def convert_pt_to_in(pt)
+    return pt / 72
+  end
+end

data/lib/img_to_pdf/version.rb

@@ -0,0 +1,3 @@
+module ImgToPdf
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: img_to_pdf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yuya.Nishida.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A tool to create PDF from raster image.
+email:
+- yuya@j96.org
+executables:
+- img_to_pdf
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/img_to_pdf
+- img_to_pdf.gemspec
+- lib/img_to_pdf.rb
+- lib/img_to_pdf/cli.rb
+- lib/img_to_pdf/cli_option.rb
+- lib/img_to_pdf/dimension.rb
+- lib/img_to_pdf/error.rb
+- lib/img_to_pdf/fit_page_document.rb
+- lib/img_to_pdf/image.rb
+- lib/img_to_pdf/integer_parser.rb
+- lib/img_to_pdf/margin.rb
+- lib/img_to_pdf/paper_size_parser.rb
+- lib/img_to_pdf/parser_error.rb
+- lib/img_to_pdf/unit.rb
+- lib/img_to_pdf/version.rb
+homepage: https://github.com/nishidayuya/img_to_pdf
+licenses:
+- X11
+metadata:
+  homepage_uri: https://github.com/nishidayuya/img_to_pdf
+  source_code_uri: https://github.com/nishidayuya/img_to_pdf
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A tool to create PDF from raster image.
+test_files: []