phari_doc_gen 1.2.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c0f0b5b7c77d8f9be2a12817c01ec137a8595b31
-  data.tar.gz: adced1d6f344949c085537b646376295520dd030
+  metadata.gz: 84e53d9f6e1da49020951dcd28ef795366414da7
+  data.tar.gz: 98e589057107d1e726ce6c275175d94a28a35b7b
 SHA512:
-  metadata.gz: 465b1a37a5dec79c6265320389e10ac99e17734a45981ab12c6f6392ee0620723c228b3841c79401ad5f6e3ad56023ceaa4ed375d953d8220a5782f3049f8a7c
-  data.tar.gz: 09d5c800618dc510f31b41488be6080a2874e7407b40455339a2287c0bc799b95a55bd2d0a12afff6e01fdf1c1e4062559423b81edbbfe0c033eee36894d2798
+  metadata.gz: cfa16be8876a0d45963dff63dabe84acf83643f3cbf2e3a46c2357b8655088cea729ccd3f68abe73b7ad91545e89ff9fac2b74704a47ee3fbdae07b4305b8dd6
+  data.tar.gz: 875ba1fcd148ee471d210652c320af69f5b56dfb28d8a3af8881d212d09adacd888be3fdf6bf004347f8caaf362a4baa09219ed92b53ac77e648d4186d95c12e

data/lib/phari_doc_gen/FileHandler.rb

@@ -1,3 +1,10 @@
+#--------------------------------------------------------------------------------------------
+# THE BEER-WARE LICENSE" (Revision 42): <luiz@phari.solutions> wrote this file.
+# As long as you retain this notice you can do whatever you want with this stuff.
+# If we meet some day, and you think this stuff is worth it, you can buy me a beer in return.
+# Luiz Philippe.
+#--------------------------------------------------------------------------------------------
+
 require 'fileutils'
 require_relative 'Modelo.rb'
 require_relative 'Rota.rb'
@@ -5,43 +12,52 @@ require_relative 'Metodo.rb'
 require_relative 'MethodParam.rb'
 
 class FileHandler
-    # Leitura dos arquivos
+    # Reading files
+    # Find a folder with the project name
     def packageExistis?(packageName)
         found = false
         package = ''
+        puts'Finding project'
+        puts'It may take some time...'
         Dir.glob('/**/' + packageName + '/') do |folder|
             package = folder unless found
             found = true
-            # puts 'done'
         end
         packagePath = package.to_s
-        # puts packagePath
         if found
+            # Return the folder path if found
             return packagePath
         else
+            # Exit if not found
             puts 'Aborting: package not found'
             exit
         end
     end
 
-    def readProject(project)
-        path = packageExistis?(project)
+    # Read the 'README.md' file and generate descriprion
+    def readProject(path)
         projectDescription = ''
-        readme = File.new(path + 'README.md')
-        projectDescription = readProjectDescription(readme)
-        projectDescription
+        if File.exists?(path + 'README.md')
+            readme = File.new(path + 'README.md')
+            projectDescription = readProjectDescription(readme)
+            projectDescription
+        else
+          puts 'Warning: No README.md file found.'
+        end
     end
 
-    def readFiles(project)
+    # Read models, helpers and controllers
+    def readFiles(path)
         models = []
-        path = packageExistis?(project)
-        Dir.glob(path + 'backend/api/models/*.rb') do |file|
+        # Find each model, helper and controller
+        Dir.glob(path + 'api/models/*.rb') do |file|
             filename = file.to_s
             inputFile = File.new(filename)
             modelname = File.basename(inputFile, '.rb')
-            helpername = path + 'backend/api/app/helpers/' + modelname + '_helper.rb'
-            controllername = path + 'backend/api/app/controllers/' + modelname + '.rb'
+            helpername = path + 'api/app/helpers/' + modelname + '_helper.rb'
+            controllername = path + 'api/app/controllers/' + modelname + '.rb'
             if File.exist?(helpername) && File.exist?(controllername)
+                # Call the necessary methods for each helper and controller
                 modelHelper = File.new(helpername, 'r')
                 modelController = File.new(controllername, 'r')
                 methods = readMethods(modelHelper, helpername)
@@ -50,37 +66,26 @@ class FileHandler
                 models << currentModel
             end
         end
+        # Return models
         models
     end
 
-    # Métodos auxiliares a leitura
+    # Auxiliary methods of reading
+
+    #Generate project descriprion based on 'README.md'
     def readProjectDescription(readme)
         isCode = false
         @projectDescription = ''
         arr = IO.readlines(readme)
+        # Read each line from the README
         arr.each do |line|
-            next if line.start_with?('# ')
-            if line.start_with?('## ')
-                line = '<h3>' + line.slice(3, line.length - 3)
-                line += '</h3>'
-                # puts line
-            end
-            if line.start_with?('### ')
-                line = '<h4>' + line.slice(4, line.length - 4) + '</h4>'
-                # puts line
-            end
-            if line.start_with?('##### ')
-                line = '<h5>' + line.slice(6, line.length - 6) + '</h5>'
-                # puts line
-            end
-            if line.start_with?('* ')
-                line = '<li>' + line.slice(2, line.length - 2) + '</li>'
-                # puts line
-            end
-            while hasBetween?(line, '**', '**')
-                line = higlightText(line)
-                # puts line
-            end
+            # Read markdown syntax and trasform into HTML tags
+            next if line.start_with?('# ') || line.start_with?('#!shell')
+            line = '<h3>' + line.slice(3, line.length - 3) + '</h3>'if line.start_with?('## ')
+            line = '<h4>' + line.slice(4, line.length - 4) + '</h4>' if line.start_with?('### ')
+            line = '<h5>' + line.slice(6, line.length - 6) + '</h5>' if line.start_with?('##### ')
+            line = '<li>' + line.slice(2, line.length - 2) + '</li>' if line.start_with?('* ')
+            line = higlightText(line) while hasBetween?(line, '**', '**')
             line = italicText(line) while hasBetween?(line, '*', '*')
             if line.include?('```')
                 if isCode
@@ -96,9 +101,11 @@ class FileHandler
             end
             @projectDescription += line
         end
+        # Return the HTML formated lines
         @projectDescription
     end
 
+    # Verify if line contains markdown syntax like **bold**
     def hasBetween?(line, stringA, stringB)
         if line.include?(stringA)
             initial = line.index(stringA)
@@ -109,6 +116,7 @@ class FileHandler
         false
     end
 
+    # Convert **bold** markdown to <b>bold</b> HTML
     def higlightText(line)
         initialIndex = line.index('**') + 2
         finalIndex = line.index('**', initialIndex)
@@ -116,10 +124,10 @@ class FileHandler
         higlightedString = line.slice(initialIndex, finalIndex - initialIndex)
         finalString = line.slice(finalIndex + 2, line.length - finalIndex + 2)
         line = initialString + '<b>' + higlightedString + '</b>' + finalString
-        # puts line
         line
     end
 
+    # Convert *italic* markdown to <i>italic</i> HTML
     def italicText(line)
         initialIndex = line.index('*') + 1
         finalIndex = line.index('*', initialIndex)
@@ -127,10 +135,10 @@ class FileHandler
         higlightedString = line.slice(initialIndex, finalIndex - initialIndex)
         finalString = line.slice(finalIndex + 1, line.length - finalIndex + 1)
         line = initialString + '<i>' + higlightedString + '</i>' + finalString
-        # puts line
         line
     end
 
+    # Convert [www.someaddress.com](text) markdown to <a href="www.someaddress.com">text</a> HTML
     def linkText(line)
         if line.include?(' [') && line.include?('](')
             initialContentIndex = line.index('[') + 1
@@ -146,6 +154,7 @@ class FileHandler
         line
     end
 
+    # Read all methods from a helper file; helper = file, helpername = file path
     def readMethods(helper, helpername)
         lineIndex = 0
         tipo = ''
@@ -157,12 +166,16 @@ class FileHandler
         toSent = true
         begin
             arr = IO.readlines(helper)
+            # Read each line from helper
             arr.each do |line|
                 lineIndex += 1
+                # Verify if it has a clause
                 if hasKeyword?(line, lineIndex, helpername)
+                    # If it does, identify which clause it is
                     arg = decodeArgument(line)
                     keyword = arg[0]
                     argument = arg[1]
+                    # Execute clause
                     case keyword
                     when 'methods'
                         if nome != ''
@@ -181,8 +194,6 @@ class FileHandler
                             toSent = true
                         end
                         nome = argument
-                    # methods.last.printName
-                    # puts "#{methods.size}"
                     when 'param'
                         data = dataValue(argument)
                         inputs << data
@@ -190,19 +201,23 @@ class FileHandler
                         data = dataValue(argument)
                         outputs << data
                     else
+                        # If a possible syntax error is found, a warning is sent informing file and linne
                         puts "Warning: in #{helpername}:#{lineIndex}: #{keyword} is not a keyword" if keyword != 'namespace'
                     end
                 end
                 descricao = decodeDescription(line) if hasDescription?(line, lineIndex, helpername)
             end
         rescue ArgumentError => e
+            # If a syntax error is found, it rais an Argument Error informing the file and line
             puts "ERROR: #{helpername}:#{lineIndex}: in #{nome}"
             puts e.message
         end
         methods << Metodo.new(nome, tipo, inputs, outputs, descricao)
+        # Return a methods array
         methods
     end
 
+    # Read all routes from a controller file; controller = file, controllername = file path
     def readRoutes(controller, controllername)
         lineIndex = 0
         tipo = ''
@@ -215,13 +230,17 @@ class FileHandler
         toSent = true
         begin
           arr = IO.readlines(controller)
+          # Read each line from controller
           arr.each do |line|
               lineIndex += 1
+              # Skip to next line if no clause is found
               next unless hasKeyword?(line, lineIndex, controllername)
+              # If it has any clause, identify which one it is
               arg = decodeArgument(line)
               keyword = arg[0]
               argument = arg[1]
               case keyword
+              # Then execute clause
               when 'route'
                   if nome != ''
                       routes << Rota.new(nome, tipo, requisicao, dataInput, inputs, outputs)
@@ -279,18 +298,24 @@ class FileHandler
                   data = dataValue(argument)
                   outputs << data
               else
+                  # If a possible syntax error is found, a warning is sent informing file and linne
+                  # (Here in the namespace comparison, i'm doing a little mcgyver)
                   puts "Warning: in #{controllername}:#{lineIndex}: #{keyword} is not a keyword" if keyword != 'namespace'
               end
           end
         rescue ArgumentError => e
+            # If a syntax error is found, it raise an Argument Error informing the file and line
             puts "ERROR: #{controllername}:#{lineIndex}: in #{nome}"
             puts e.message
         end
         routes << Rota.new(nome, tipo, requisicao, dataInput, inputs, outputs)
+        # Return a routes array
         routes
     end
 
-    # Métodos de decodificação da leitura
+    # Decoding clauses methods
+
+    # Verify if a given line has any clause
     def hasKeyword?(line, lineIndex, fileName)
         if (line.include? '#') && (line.include? '@')
             for i in 0..line.index('#')-1
@@ -301,16 +326,20 @@ class FileHandler
             for i in line.index('#')+1..line.index('@')-1
                 if line[i].match(/^[[:alpha:]]$/)
                   lineText = line.slice(line.index('#'), line.index("\n") - line.index('#'))
+                  # A warning informing file and line is sent if a possible error is found
                   puts "Warning: in #{fileName}:#{lineIndex}: #{lineText} is not a keyword"
                   return false
                 end
             end
+            # Return true if it do
             true
         else
+            # And false if it don't
             false
         end
     end
 
+    # The ** description clause has his own method seen that it has different syntax
     def hasDescription?(line, lineIndex, fileName)
         if (line.include? '#') && (line.include? '**')
           for i in 0..line.index('#')-1
@@ -321,22 +350,27 @@ class FileHandler
           for i in line.index('#')+1..line.index('**')-1
               if line[i].match(/^[[:alpha:]]$/)
                 lineText = line.slice(line.index('#'), line.index("\n") - line.index('#'))
+                # A warning informing file and line is sent if a possible error is found
                 puts "Warning: in #{fileName}:#{lineIndex}: #{lineText} is not a description"
                 return false
               end
           end
+          # Return true if it has description clause
           true
         else
+            # And false if it don't
             false
         end
     end
 
+    # Decode which clause is on a given line, and which arguments
     def decodeArgument(line)
         args = []
         initialIndex = line.index('@') + 1
         finalIndex = line.index("\s", line.index('@'))
         if finalIndex == nil || initialIndex == nil
           if line.index('@')+1 == /^[[:alpha:]]$/
+            # Raises an Argument Error if some error is found
             raise ArgumentError.new("Sytanx error: expected 2 arguments (one given)")
           else raise ArgumentError.new("Sytanx error: expected 2 arguments (none given)")
           end
@@ -346,15 +380,17 @@ class FileHandler
         argument = line.slice(finalIndex + 1, line.size - finalIndex)
         args << keyword
         args << argument
+        # Return array with clause and arguments
         args
     end
 
+    # If the clause is a param or return value, decode the name and datatype
     def dataValue(argument)
         if argument.include? "\s"
             name = argument.slice(0, argument.index("\s"))
-            type = argument.slice(argument.index("\s") + 1, argument.size - 1)
+            type = argument.slice(argument.index("\s") + 1, argument.size - 2)
             data = MethodParam.new(name, type)
-            # data.printSelf
+            # Return the data
             return data
         elsif argument.include? "nil"
             data = MethodParam.new('', 'nil')
@@ -364,46 +400,62 @@ class FileHandler
             return data
         end
         argumentText = argument.slice(0, argument.index("\n"))
+        # If any information is missing or incorrect, raises an Argument Error
         raise ArgumentError.new("Sytanx error: #{argumentText} is no data")
     end
 
+    # Decode the text from a description clause
     def decodeDescription(line)
         initialIndex = line.index('*') + 3
         lenght = line.size - initialIndex
         description = line.slice(initialIndex, lenght)
-        # puts "#{description}"
+        # Return the description text
         description
     end
 
-    # Escrita dos arquivos
-    def writeFiles(models, project, projectDescription, path)
-        FileUtils.mkdir_p(path + 'css')
-        css = File.open(path + 'css/master.css', 'w')
+    # File writing
+    def writeFiles(models, projectName, projectDescription, path)
+        outputFolder = path + "#{projectName}_PhariDoc/"
+        FileUtils.mkdir_p(outputFolder)
+        # Create the css/master.css file, which is default for any project
+        FileUtils.mkdir_p(outputFolder + 'css/')
+        css = File.open(outputFolder + 'css/master.css', 'w')
         writeCSS(css)
         css.close
-        projectHTML = File.open(path + 'project.html', 'w')
+        # Write the project main page
+        projectHTML = File.open(outputFolder + 'project.html', 'w')
         writeHeader(projectHTML)
-        writeProjectPage(project, projectHTML, models, projectDescription)
+        writeProjectPage(projectName, projectHTML, models, projectDescription)
         projectHTML.close
-        FileUtils.mkdir_p(path + 'models')
+        # Write each model's page
+        FileUtils.mkdir_p(outputFolder + 'models/')
         models.each do |model|
             name = model.name.downcase
-            modelHTML = File.open(path + "models/#{name}.html", 'w')
+            modelHTML = File.open(outputFolder + "models/#{name}.html", 'w')
             writeHeaderInDir(modelHTML)
-            writeModelPage(modelHTML, model)
+            writeModelPage(modelHTML, model, projectName)
+            modelHTML.close
         end
     end
 
+    # Write the css content
     def writeCSS(file)
         file.write("body{
-    background-color: #702794;
+    background-color: #2CA896;
   }
   a{
+    color: #2CA896;
+  }
+  a:hover{
     color: #333;
   }
   li{
     padding-left: 3%;
   }
+  code{
+    background-color: #DDD;
+    color: black;
+  }
   .logo{
     margin: 5%;
   }
@@ -418,6 +470,7 @@ class FileHandler
   }")
     end
 
+    # Write the HTML header
     def writeHeader(file)
         file.write("<!DOCTYPE html>
 
@@ -441,6 +494,7 @@ class FileHandler
             <br><br><br>")
     end
 
+    # Write the HTML header with relative paths
     def writeHeaderInDir(file)
         file.write("<!DOCTYPE html>
 
@@ -464,6 +518,7 @@ class FileHandler
             <br><br><br>")
     end
 
+    #Write the main project HTML content
     def writeProjectPage(project, file, models, description)
         file.write("<div class='container panel panel-default'>
           <div class='row'>
@@ -496,13 +551,14 @@ class FileHandler
     </body>")
     end
 
-    def writeModelPage(file, model)
+    # Write a model HTML page content
+    def writeModelPage(file, model, project)
         name = model.name.capitalize
         file.write("<div class='container panel panel-default'>
           <div class='row'>
             <div class='panel panel-default'>
               <div class='panel-heading'>
-                <h1>PhariSchool</h1>
+                <h1>#{project}</h1>
               </div>
               <div class='panel-body'>
                 <h2>#{name} Model</h2>
@@ -525,15 +581,15 @@ class FileHandler
             outputs = method.outputs
             description = method.description
             file.write("            <div class='list-group-item'>
-                          <h4 class='list-group-item-heading'>#{type} - #{name}</h4>
-                          <p><br>Input:<br>
+                          <h4 class='list-group-item-heading'>CRUD: #{type}<br>Name: #{name}</h4>
+                          <p><br>Inputs:<br>
                           <ul>")
             inputs.each do |input|
                 type = input.type
                 name = input.name
                 file.write("<li>#{type}: #{name}</li>")
             end
-            file.write("</ul><br>Output:<br>
+            file.write("</ul><br>Outputs:<br>
                               <ul>")
             outputs.each do |output|
                 if output != 'nil'
@@ -565,17 +621,17 @@ class FileHandler
             inputs = route.inputs
             outputs = route.outputs
             file.write("            <div class='list-group-item'>
-                          <h4 class='list-group-item-heading'>Route type #{type} - #{name}</h4>
+                          <h4 class='list-group-item-heading'>CRUD: #{type}<br>Name: #{name}</h4>
                           <p><br>Request: #{request}<br>
                           <br>Notation type: #{dataInput}<br>
-                          <br>Input:<br>
+                          <br>Inputs:<br>
                           <ul>")
             inputs.each do |input|
                 type = input.type
                 name = input.name
                 file.write("<li>#{type}: #{name}</li>")
             end
-            file.write("</ul><br>Output:<br>
+            file.write("</ul><br>Outputs:<br>
                               <ul>")
             outputs.each do |output|
                 if output != 'nil'

data/lib/phari_doc_gen/MethodParam.rb

@@ -1,3 +1,10 @@
+#--------------------------------------------------------------------------------------------
+# THE BEER-WARE LICENSE" (Revision 42): <luiz@phari.solutions> wrote this file.
+# As long as you retain this notice you can do whatever you want with this stuff.
+# If we meet some day, and you think this stuff is worth it, you can buy me a beer in return.
+# Luiz Philippe.
+#--------------------------------------------------------------------------------------------
+
 class MethodParam
     @name = ''
     @type = ''

data/lib/phari_doc_gen/Metodo.rb

@@ -1,3 +1,10 @@
+#--------------------------------------------------------------------------------------------
+# THE BEER-WARE LICENSE" (Revision 42): <luiz@phari.solutions> wrote this file.
+# As long as you retain this notice you can do whatever you want with this stuff.
+# If we meet some day, and you think this stuff is worth it, you can buy me a beer in return.
+# Luiz Philippe.
+#--------------------------------------------------------------------------------------------
+
 require_relative 'MethodParam.rb'
 
 class Metodo

data/lib/phari_doc_gen/Modelo.rb

@@ -1,3 +1,10 @@
+#--------------------------------------------------------------------------------------------
+# THE BEER-WARE LICENSE" (Revision 42): <luiz@phari.solutions> wrote this file.
+# As long as you retain this notice you can do whatever you want with this stuff.
+# If we meet some day, and you think this stuff is worth it, you can buy me a beer in return.
+# Luiz Philippe.
+#--------------------------------------------------------------------------------------------
+
 class Modelo
     @methods = []
     @routes = []

data/lib/phari_doc_gen/Rota.rb

@@ -1,3 +1,10 @@
+#--------------------------------------------------------------------------------------------
+# THE BEER-WARE LICENSE" (Revision 42): <luiz@phari.solutions> wrote this file.
+# As long as you retain this notice you can do whatever you want with this stuff.
+# If we meet some day, and you think this stuff is worth it, you can buy me a beer in return.
+# Luiz Philippe.
+#--------------------------------------------------------------------------------------------
+
 class Rota
     @type = ''
     @name = ''

data/lib/phari_doc_gen.rb

@@ -1,3 +1,10 @@
+#--------------------------------------------------------------------------------------------
+# THE BEER-WARE LICENSE" (Revision 42): <luiz@phari.solutions> wrote this file.
+# As long as you retain this notice you can do whatever you want with this stuff.
+# If we meet some day, and you think this stuff is worth it, you can buy me a beer in return.
+# Luiz Philippe.
+#--------------------------------------------------------------------------------------------
+
 require 'fileutils'
 require_relative 'phari_doc_gen/Modelo.rb'
 require_relative 'phari_doc_gen/Rota.rb'
@@ -6,29 +13,31 @@ require_relative 'phari_doc_gen/MethodParam.rb'
 require_relative 'phari_doc_gen/FileHandler.rb'
 
 class PhariDocGen
-  def generate (project, path)
-      if project == nil
+  # Generate documentation for standard projects
+  def generate (project, outputPath)
+      generate = FileHandler.new
+      # Ask for project name if nil
+      if project.nil?
           puts "Insert project which generate documentation"
           project = gets.chomp
+          while project == ''
+              project = gets.chomp
+          end
       end
-      if project == ''
-          puts 'Aborting generation due to empty project name'
-          exit
-      end
-      generate = FileHandler.new
-      projectDescription = generate.readProject(project)
-      models = generate.readFiles(project)
-      if path == nil
-          puts 'Insert full path to output file'
-          path = gets.chomp
-      end
-      path += '/' unless path.end_with?('/')
-      path = '/'+path unless path.start_with?('/')
-      if path == ''
-          puts 'Aborting generation due to empty path'
-          exit
+      # Verify the existence of the project
+      projectPath = generate.packageExistis?(project)
+      # Get description from README.md
+      projectDescription = generate.readProject(projectPath)
+      # Get models with their methods and routes
+      models = generate.readFiles(projectPath)
+      # Specify the output path
+      if outputPath.nil?
+          outputPath = ''
+      else
+          outputPath += '/' unless outputPath.end_with?('/')
       end
-      generate.writeFiles(models, project, projectDescription, path)
+      # Write documentation
+      generate.writeFiles(models, project, projectDescription, outputPath)
       puts 'Done!'
   end
 end

metadata

@@ -1,24 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: phari_doc_gen
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 2.0.0
 platform: ruby
 authors:
-- Phari
+- Phari Solutions
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-25 00:00:00.000000000 Z
+date: 2017-05-21 00:00:00.000000000 Z
 dependencies: []
-description: A documentation generator gem for projects following sinatra-padrino
-  patterns.
-email: luizphilippep@gmail.com
+description: |2-
+   Hi there buddy! I've heard you've been looking for a simple
+                      and functional documentation generator for this Ruby web app
+                      of yours. So here goes a brief tutorial on how to use this
+                      little gem developed by Phari Solutions. First things first.
+                      To use this gem, you will need to be following the sinatra/padrino
+                      patterns. If you're using those frameworks probably you already
+                      matched the requisites, otherwise, organize your folders properly.
+                      Your project tree has to be organized in a main directory called
+                      'api' that must contain another folder 'app' with three other
+                      directories 'models', 'helpers' and 'controllers' within. The files will
+                      also have to be especifically named. But we'll look further into it
+                      later. Now, requisites aside, Phari Doc Generator will provide you
+                      an easy way to generate documentation for your projects. The result
+                      will be a project page with a description that can be written using a simplified
+                      markdown syntax that is going to be explained ahead. Also, each ruby
+                      Class will have it's own page especifying it's helper methods and controllers
+                      routes including their inputs, outputs and descriptions. The gem includes
+                      an executable file and the classes that can be used individually,
+                      providing the possibility to use the generator for any project
+                      structure. See full documentation in:
+email: contact@phari.solutions
 executables:
-- generate
+- phari_doc_gen
 extensions: []
 extra_rdoc_files: []
 files:
-- bin/generate
+- bin/phari_doc_gen
 - lib/phari_doc_gen.rb
 - lib/phari_doc_gen/FileHandler.rb
 - lib/phari_doc_gen/MethodParam.rb
@@ -27,7 +46,7 @@ files:
 - lib/phari_doc_gen/Rota.rb
 homepage: ''
 licenses:
-- MIT
+- Beerware
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -48,5 +67,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: 'Main classes: PhariDocGen && PhariDocGen/FileHandler'
+summary: 'Main classes: PhariDocGen && FileHandler'
 test_files: []