groff_parser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 406e4d48011a846f365a37621e4ba1d91a9e5e35
+  data.tar.gz: 02d97ad12f839e36b35ff9d7c82197e935e218c8
+SHA512:
+  metadata.gz: 464732dbc63162c610ce01ec69e533ecd48bd4ae59893d5f26f9b3b3b3e4f3dcaee209573e8ac5fbc5c4daff547dfbd2828e0454a80b1ef47ffe79db426c42fd
+  data.tar.gz: c80a4373eceaf28529e77d99323dc4fe308bc65518a2d18eb5551fee48482aa8f37aab212166513d22812444b1548d2c185b1998492be081c3d31f2bfdbcb3e6

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.inch

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'simplecov', require: false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Roberto Dip
+
+MIT 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,35 @@
+# GroffParser
+
+### Status
+[![Gem Version](https://badge.fury.io/rb/groff_parser.png)](http://badge.fury.io/rb/groff_parser)
+[![Code Climate](https://codeclimate.com/github/roperzh/groff_parser.png)](https://codeclimate.com/github/roperzh/groff_parser)
+[![Dependencies](https://gemnasium.com/roperzh/groff_parser.png)](https://gemnasium.com/roperzh/groff_parser)
+
+Tiny library to parse groff files, with some handy metods to manage directories with a lot of files
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'groff_parser'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install groff_parser
+
+## Basic Usage
+
+Coming soon, in the meantime you can read the [`docs`](http://rubydoc.info/gems/)
+
+
+## Contributing
+
+1. Fork it ( http://github.com/roperzh/groff_parser/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.libs.push 'test'
+end
+
+namespace :test do
+  task :coverage do
+    ENV['COVERAGE'] = 'true'
+    Rake::Task['test'].invoke
+  end
+end
+
+task default: :test
+

data/groff_parser.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'groff_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "groff_parser"
+  spec.version       = GroffParser::VERSION
+  spec.authors       = ["Roberto Dip"]
+  spec.email         = ["dip.jesusr@gmail.com"]
+  spec.summary       = %q{Just a little gem to handle groff files}
+  spec.description   = %q{Tiny library to parse groff files, with some handy metods to manage directories with a lot of files}
+  spec.homepage      = "https://github.com/roperzh/groff_parser"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'minitest',      '~> 5'
+  spec.add_development_dependency "inch"
+end

data/lib/groff_parser.rb

@@ -0,0 +1,7 @@
+require "groff_parser/engine"
+
+# A module to namespace all the classes and methods involved in the
+# parsing of the documents
+
+module GroffParser; end
+

data/lib/groff_parser/document.rb

@@ -0,0 +1,98 @@
+module GroffParser
+
+  # A class representing a specific document to be parsed
+
+  class Document
+
+    # Initializes the document class
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   zipped_document = GroffParser::Document.new("path/to/file.gz", zipped: true)
+    #   unzipped_document = GroffParser::Document.new("path/to/file.1",  zipped: false)
+    #
+    # @param path [String] the path where the document is located
+    #
+    # @param zipped [Boolean] indicates if the document is zipped or not
+    #
+    # @return [GroffParser::Document] a new instance of a Document class
+
+    def initialize(path, zipped: false)
+      @path   = path
+      @zipped = zipped
+    end
+
+    # Currently in beta, given a section name it tries to search within the
+    # current document for a title passed as a parameter and return the contents
+    # within the title and the next one
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   document.section("MY SECTION")
+    #   # searches for a section like this one:
+    #   # .SH
+    #   #  MY SECTION
+    #   #  ...
+    #
+    # @param name [String, Symbol] name of the section
+    #
+    # @return [String, nil] the contents of the section or nil if the section
+    #   doesn't exist yet
+
+    def section(name)
+      raw_content[/SH \"#{name}\"(.*?)SH/im].gsub("SH", "")
+    end
+
+    # Raw content of the document, without being parsed, in pure
+    # groff format
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   document.raw_content
+    #
+    # @return [String] the document content in groff format
+
+    def raw_content
+      @raw_content ||= `#{get} #{@path}`
+    end
+
+    # Content of the document in a especific format
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   document.formatted_content(:html)
+    #
+    # @param format [Symbol, String] indicates the output format, could be:
+    #   dvi, html, lbp, lj4, ps, ascii, cp1047, latin1, utf8, X75, X75, X100, X100
+    #
+    # @return [String] the document content formated in the requested format
+
+    def formatted_content(format)
+      `#{get} #{@path} | groff -mandoc -T#{format}`
+    end
+
+    private
+
+    # Little helper to know which command should be executed in order to parse
+    # files properly
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   @zipped = true
+    #   get # => "zcat"
+    #
+    #   @zipped = false
+    #   get # => "cat"
+    #
+    # @return [String] the proper parameter
+
+    def get
+      @zipped ? "zcat" : "cat"
+    end
+  end
+end

data/lib/groff_parser/engine.rb

@@ -0,0 +1,113 @@
+require "groff_parser/document"
+
+module GroffParser
+
+  # A handy class who offers some methods to handle multiple documents at the
+  # same time
+
+  class Engine
+
+    # @since 0.1.0
+    attr_accessor :path
+
+    # Stores a path, this one can be a path to a directory or to an specific
+    # file, use the proper class methods is up to you
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   GroffParser::Engine.new("path/to/file")
+    #   GroffParser::Engine.new("path/to/directory")
+    #
+    # @param path [String] the path to be stored
+    #
+    # @return [GroffParser::Engine] a new Engine instance
+
+    def initialize(path: Dir.pwd)
+      @path = path
+    end
+
+    # Parse a document located on a given path, if the document is contained
+    # inside of the `@path` variable you can pass only the document name
+    # otherwise it searchs for path provided as a full path
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   parser = GroffParser::Engine.new("some/path")
+    #   parser.parse("path/to/another_file")
+    #   # Will parse another_file properly
+    #   parser.parse("some_file")
+    #   # Will search for a file called some_file in some/path
+    #
+    # @param document_path [String] path for a document to parse
+    #
+    # @param zipped [Boolean] indicates if the file is zipped or not (gzip)
+    #
+    # @param format [Symbol, String] indicates the output format, could be:
+    #   dvi, html, lbp, lj4, ps, ascii, cp1047, latin1, utf8, X75, X75, X100, X100
+    #
+    # @return [String] the content of the document, parsed in the proper format
+
+    def parse(document_path, zipped, format: :utf8)
+      dpath = document_path.include?(path) ? document_path : "#{path}/#{document_path}"
+
+      Document.new(dpath, zipped: zipped).formatted_content(format)
+    end
+
+    # Parse all documents in a given directory, with a given format
+    #
+    # @since 0.1.0
+    #
+    # @param format [Symbol, String] indicates the output format, could be:
+    #   dvi, html, lbp, lj4, ps, ascii, cp1047, latin1, utf8, X75, X75, X100, X100
+    #   (default = utf8)
+    #
+    # @param zipped [Boolean] indicates if the file is zipped or not (gzip)
+    #
+    # @return [Array] an array of all the parsed documents
+
+    def parse_all(format: :utf8, zipped: false)
+      documents   = []
+      search_path = zipped ? "#{path}/*.gz" : "#{path}/*[0-9]"
+
+      Dir.glob(search_path) do |document|
+        documents << parse(document, zipped, format: format)
+      end
+
+      documents
+    end
+
+    # Executes a passed block, giving a GroffParser::Document as argument
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #  parser = GroffParser::Engine.new("/path/to/file")
+    #  parser.apply { |document| document.parse }
+    #
+
+    def apply(*args)
+      yield parse(args.join(" "))
+    end
+
+    # Executes a passed block over all the documents in the current directory,
+    # giving a GroffParser::Document as argument for each block execution
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   parser = GroffParser::Engine.new("/folder/with/some/files")
+    #   parser.apply_all { |document|  document.parse }
+    #
+    # @return [nil]
+
+    def apply_all(*args)
+      search_path = args[0][:zipped] ? "#{path}/*.gz" : "#{path}/*"
+
+      Dir.glob(search_path) do |document|
+        yield parse(*args)
+      end
+    end
+  end
+end

data/lib/groff_parser/version.rb

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

data/test/document_test.rb

@@ -0,0 +1,73 @@
+require "test_helper"
+
+describe GroffParser::Document do
+
+  let(:zipped_document)   {
+    GroffParser::Document.new("test/fixtures/git.1.gz", zipped: true)
+  }
+
+  let(:unzipped_document) {
+    GroffParser::Document.new("test/fixtures/git.1", zipped: false)
+  }
+
+  describe "#section" do
+    it "returns the contents of a section delimited by a given title" do
+      zipped_document.section("NAME").must_equal(
+        " \"NAME\"\ngit \\- the stupid content tracker\n."
+      )
+
+      unzipped_document.section("NAME").must_equal(
+        " \"NAME\"\ngit \\- the stupid content tracker\n."
+      )
+    end
+
+    it "returns the same results whether the document is zipped or not" do
+      zipped_document.section("NAME").must_equal(
+        unzipped_document.section("NAME")
+      )
+    end
+  end
+
+  describe "#raw_content" do
+    it "returns the content in groff format" do
+      zipped_raw_content   = `zcat test/fixtures/git.1.gz`
+      unzipped_raw_content = `cat test/fixtures/git.1`
+
+      zipped_document.raw_content.must_equal zipped_raw_content
+      unzipped_document.raw_content.must_equal unzipped_raw_content
+    end
+
+    it "returns the same results whether the document is zipped or not" do
+      zipped_document.raw_content.must_equal(
+        unzipped_document.raw_content
+      )
+    end
+  end
+
+  describe "#formatted_content" do
+    let(:timestamp) { Regexp.new(/\<\!\-\- CreationDate\: (.*?) \-\-\>/) }
+
+    it "returns the content in the requested format" do
+      # Due to a small delay parsing data, we need to supress the timestamps
+      method_content_from_zip = zipped_document.formatted_content(:html)
+        .gsub(timestamp, "")
+
+      method_content_from_unzip = unzipped_document.formatted_content(:html)
+        .gsub(timestamp, "")
+
+      method_content_from_zip.must_equal(
+        `zcat test/fixtures/git.1.gz | groff -mandoc -Thtml`.gsub(timestamp, "")
+      )
+
+      method_content_from_unzip.must_equal(
+        `cat test/fixtures/git.1 | groff -mandoc -Thtml`.gsub(timestamp, "")
+      )
+    end
+
+    it "returns the same results whether the document is zipped or not" do
+      zipped_document.formatted_content(:html).gsub(timestamp, "").must_include(
+        unzipped_document.formatted_content(:html).gsub(timestamp, "")
+      )
+    end
+  end
+end

data/test/engine_test.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.join("test/test_helper"))
+
+describe GroffParser::Engine do
+
+  let(:engine) { GroffParser::Engine.new(path: "test/fixtures") }
+
+  describe "#parse" do
+    it "returns the contents of a document, formatted by the requested format" do
+      engine.parse("git.1.gz", true, format: :utf8).must_equal(
+        `cat test/fixtures/git.1 | groff -mandoc -Tutf8`
+      )
+    end
+  end
+
+  describe "#parse_all" do
+    it "returns an array with all the documents contents present in the path" do
+      engine.parse_all.must_equal(
+        [`cat test/fixtures/git.1 | groff -mandoc -Tutf8`]
+      )
+    end
+  end
+end