jg_piawe 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b7381321f2b5b45971f4b9d13140872b395ae31d
+  data.tar.gz: aff58d71e43d64d21ba381535a9c5f4f76531f07
+SHA512:
+  metadata.gz: f46d0e44fe3db1ca1d43f1b2086f923b387635489047b76a3daf7231a66f5e321311467020680186575ac9d80e969e7f0349d6f350a4e9b6c710b91af737debf
+  data.tar.gz: 09c31fdd61202a81202baa68166d454ee14085519b4b89c3eebe744d3c5273c24c90280b562aa0a5d8539baa4e936cac61fe529cf25e4f70f4c4d83bc96f914a

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+	add_group "lib", "lib"
+end

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in piawe.gemspec
+gemspec

data/README.md

@@ -0,0 +1,43 @@
+# Piawe
+
+This gem implements a PIAWE report generator
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jg_piawe'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jg_piawe
+
+## Usage
+
+Once the gem has been installed, PIAWE reports can be produced using the piawe_report command line utility. The syntax for this utility is:
+
+```
+piawe_report peopleFile rulesFile [reportDate]
+```
+e.g.:
+```
+piawe_report ~/workspace/piawe/spec/files/people.json ~/workspace/piawe/spec/files/rules_fixed.json '2017/02/01'
+```
+
+The date parameter is optional - it will default to the current date if omitted.
+
+The report will be output to stdout.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `lib/piawe/version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

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

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/piawe_report

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'piawe'
+
+#tosimpletotest
+if [2,3].include? ARGV.size
+	puts Piawe::FileParser.new( ARGV[0], ARGV[1], ARGV.size > 2 ? ARGV[2] : Date.today.strftime('%Y/%m/%d') ).report
+else
+	puts "Usage:"
+	puts "piawe_report peopleFile rulesFile [reportDate]"
+end

data/lib/piawe/file_parser.rb

@@ -0,0 +1,67 @@
+# Class to read people and rules files and convert them into a PIAWE report
+class Piawe::FileParser
+
+	# Create a new FileParser to generate a PIAWE report from files
+	# 
+  #
+  # ==== Parameters
+  #
+  # * +people_file_name+ - Fully qualified path of the people file
+  # * +rules_file_name+ - Fully qualified path of the rules file
+  # * +report_date_string+ - Report date to use, in YYYY/MM/DD format
+  #
+	def initialize( people_file_name, rules_file_name, report_date_string )
+		@people_file_name = people_file_name
+		@rules_file_name = rules_file_name
+		@report_date_string = report_date_string
+	end
+
+	# Generate a JSON hash containing the PIAWE report
+	def report
+		JSON.pretty_generate( { piawe_report: Piawe.new( people_array, rules_array ).report( report_date ) } )
+	end
+
+private
+
+	def people_array
+		people_hash["people"] || (raise ArgumentError, "people hash did not contain a people key!")
+	end
+
+
+	def people_hash
+		JSON.parse people_file.read
+	end
+
+
+	def people_file
+		File.exist?(@people_file_name) ? File.new(@people_file_name) : (raise ArgumentError, "Could not find file #{@people_file_name}")
+	end
+
+
+	def rules_array
+		rules_hash["rules"] || (raise ArgumentError, "rules hash did not contain a rules key")
+	end
+
+
+	def rules_hash
+		JSON.parse rules_file.read
+	end
+
+
+	def rules_file
+		File.exist?(@rules_file_name) ? File.new(@rules_file_name) : (raise ArgumentError, "Could not find file #{@rules_file_name}")
+	end
+
+
+	def report_date
+		/^(?<yyyy>\d{4})\/(?<mm>\d{2})\/(?<dd>\d{2})$/ =~ @report_date_string || (raise ArgumentError, "report_date_string was not in YYYY/MM/DD format")
+		result = nil
+		begin
+			result = Date.new(yyyy.to_i, mm.to_i, dd.to_i)
+		rescue ArgumentError => ex
+			raise ArgumentError, "report_date_string does not represent a valid date: #{@report_date_string}"
+		end
+		result
+	end
+
+end

data/lib/piawe/rule_set.rb

@@ -0,0 +1,179 @@
+require 'bigdecimal'
+require 'role_playing'
+
+# Class to encapsulate a set of PIAWE payment rules
+class Piawe::RuleSet
+
+	include RolePlaying::Context
+
+
+	# Create a new RuleSet to represent the rules contained in a rules array
+	# 
+  #
+  # ==== Parameters
+  #
+  # * +rules_array+ - An array of rule hashes
+  #
+  # ==== Rule Hash
+  #
+  # A rule hash it a Ruby hash that has has the following format:
+  #
+	#   {"rules":[
+	#     {"applicableWeeks": "1-26", "percentagePayable": 90, "overtimeIncluded": true},
+	#     {"applicableWeeks": "27-52", "percentagePayable": 80, "overtimeIncluded": true},
+	#     {"applicableWeeks": "53-79", "percentagePayable": 70, "overtimeIncluded": true},
+	#     {"applicableWeeks": "80-104", "percentagePayable": 60, "overtimeIncluded": false},
+	#     {"applicableWeeks": "105+", "percentagePayable": 10, "overtimeIncluded": false}
+	#   ]}
+	#
+	# * applicableWeeks - A String that indicates the range of injury weeks during which the rule applies - Week 1 starts at the day of the injury, and Week 2 starts on the 7th day after the injury, and so on.  It can have two formats: either a start week and end week joined by a dash, or a start week followed by a plus sign, which indicates the rule should apply to all later weeks as well. The first rule must have a start week of 1, the last rule must use the plus sign syntax, and all intervening rules must have a start week that is one greater than the end week of the preceeding rule.
+	#
+	# * percentagePayable - A Numeric that indicates the percentage of Average Weekly Earnings that are paid when this rule applies.
+	#
+	# * overtimeIncluded - A TrueClass or FalseClass that indicates whether overtime earnings should be considered part of Average Weekly Earnings when this rule applies.
+	def initialize(rules_array)
+		rules_array && rules_array.is_a?(Array) || (raise ArgumentError, "rules array is required - got #{rules_array.inspect}")
+		rules_array.size > 0 || (raise ArgumentError, "rules array must contain at least one entry")
+		rules_array.each do |rule_hash|
+			add(Rule.played_by rule_hash)
+		end
+		rules[-1].end_week.nil? || (raise ArgumentError, "last rule must have a terminating + sign")
+	end
+
+
+	# Based on the included Rules, generate a report line for a given person at a given report date
+	# This is included in the RuleSet class for expedience - a cleaner separation of concerns could be 
+	# achieved by factoring this method into a report generator class, that calls a RuleSet.get_rule(person, report_date) method.
+	# 
+  #
+  # ==== Parameters
+  #
+  # * +person+ - The Piawe::Person for whom the report line should be generated
+  #
+  # * +report_date+ - The Date for which the report line should be generated
+  #
+	def report_line(person, report_date)
+		rules.each do |rule|
+			return rule.report_line( person, report_date ) if rule.matches?( person.weeks_since_injury( report_date ) ) 
+		end # each rule
+		# this should not be possible - but putting this here defensively...
+		raise "APPLICATION BUG - A RuleSet EXISTS THAT DOES NOT COVER ALL POSSIBLE DATES!! (Date was #{report_date.strftime('%Y/%m/%d')}, person was #{person.inspect})"
+	end # method payment_report
+
+
+
+
+
+	private
+
+
+		def add(rule)
+			# check consistency of rule dates
+			(rule.end_week.nil? || rule.end_week > rule.start_week) || (raise ArgumentError, "rule #{rules.size + 1} has an end week of #{rule.end_week} that is not later than it's start week of #{rule.start_week}")
+			if rules[-1] # we have existing rules, check we are consistent
+				rules[-1].end_week || (raise ArgumentError, "rule #{rules.size} has a terminating + sign, and should have been the last rule, however there was a subsequent rule: #{rule.inspect}")
+				rule.start_week == rules[-1].end_week + 1 || (raise ArgumentError, "rule #{rules.size} ends at week #{rules[-1].end_week} but rule #{rules.size + 1} starts at week #{rule.start_week} - each rule should start one week after the prior rule ends")
+			else # this should be the first rule - check it's start date
+				1 == rule.start_week || (raise ArgumentError, "rule 1 should start at week 1, but starts at week #{rule.start_week}")
+			end # if we have existing rules
+			rules << rule
+		end # method add
+
+
+		def rules 
+			@rules ||= []
+		end
+
+
+
+
+		# role to be added to a rule hash
+		role :Rule do
+
+			def start_week
+				@start_week ||= (
+					/(?<starting_week>\d+)[+-]/ =~ applicable_weeks
+					starting_week.to_i
+				)
+			end 
+
+
+			def end_week
+				@end_week ||= if /\+$/ =~ applicable_weeks
+												nil
+											else
+												( /\d*\-(?<ending_week>\d+)$/ =~ applicable_weeks ) || (raise ArgumentError, "invalid applicableWeeks value: #{applicable_weeks}")
+												ending_week.to_i
+											end # if trailing + sign
+			end
+
+
+			def applicable_weeks
+				@applicable_weeks ||= (
+					self.has_key?("applicableWeeks") || (raise ArgumentError, "rule hash did not have an applicableWeeks key: #{self.inspect}")
+					/(^\d+\-\d+$)|(^\d+\+$)/ =~ self["applicableWeeks"] || (raise ArgumentError, "applicableWeeks key is not in valid format")
+					self["applicableWeeks"]
+				)
+			end
+
+
+			def percentage_payable
+				self.has_key?("percentagePayable") || (raise ArgumentError, "rule_hash does not have a percentagePayable key: #{self.inspect}")
+				self["percentagePayable"].is_a?(Numeric) || (raise ArgumentError, "rule_hash has a non-numeric value for percentagePayable key: #{self['percentagePayable']}")
+				BigDecimal.new self["percentagePayable"]
+			end
+
+
+			def overtime_included
+				self.has_key?("overtimeIncluded") || (raise ArgumentError, "rule_hash does not have an overtimeIncluded key: #{self.inspect}")
+				( self["overtimeIncluded"].is_a?(TrueClass) || self["overtimeIncluded"].is_a?(FalseClass) )  || (raise ArgumentError, "overtimeIncluded value was not a boolean true or false - value was #{ self['overtimeIncluded'] }" )
+				self["overtimeIncluded"]
+			end
+
+			# The weeks_since_injury value is interpreted as a statement of which injury week we 
+			# are currently in - the first week commencing at the date of the injury, the second week
+			# commencing 7 days after that date etc.
+			def matches?(weeks_since_injury)
+				weeks_since_injury >= (start_week - 1).to_f && # it's after the prior week, i.e. when injured, you are immediately in the first 
+				                                          # week of injury
+				(
+					end_week.nil? ||
+					weeks_since_injury <  end_week.to_f  # it's before the end_week number - i.e. exactly 1 week after an injury,
+				  			                               # you are now into the second week of injury
+				)				                                          
+			end
+
+
+			def pay_for_this_week( person )
+				(
+					( 
+						person.normal_hours * person.hourly_rate + ( 
+							overtime_included ? person.overtime_hours * person.overtime_rate : 0 
+						) 
+					) * ( percentage_payable / 100 )
+				).round(2)
+			end
+
+
+			def report_line(person, report_date)
+				{
+					name: person.name,
+					pay_for_this_week: 	sprintf( "%.2f", pay_for_this_week(					person 			) ),
+					weeks_since_injury: sprintf( "%.2f", person.weeks_since_injury( report_date ) ),
+					hourly_rate: 				sprintf( "%.6f", person.hourly_rate												),
+					overtime_rate: 			sprintf( "%.6f", person.overtime_rate											),
+					normal_hours: 			sprintf( "%.2f", person.normal_hours											),
+					overtime_hours: 		sprintf( "%.2f", person.overtime_hours										),
+					percentage_payable: sprintf( "%.2f", percentage_payable												),
+					overtime_included: 	overtime_included.to_s
+				}
+			end # method report_line
+
+		end # role Rule
+
+
+
+end # class Piawe::RuleSet
+
+
+

data/lib/piawe/version.rb

@@ -0,0 +1,3 @@
+class Piawe
+  VERSION = "0.1.1"
+end

data/lib/piawe.rb

@@ -0,0 +1,143 @@
+require 'piawe/version'
+require 'piawe/rule_set'
+require 'piawe/file_parser'
+require 'role_playing'
+require 'date'
+require 'bigdecimal'
+
+# Class to encapsulate PIAWE report generation
+class Piawe
+
+	include RolePlaying::Context
+
+	# Create a new Piawe instance to generate reports for a particular set of people and rules
+	# 
+  #
+  # ==== Parameters
+  #
+  # * +people_array+ - An array of people hashes
+  #
+  # * +rules_array+ - An array of rule hashes
+  #
+  # ==== People Hash
+  #
+  # A people hash it a Ruby hash that has has the following format:
+  #
+	#		{"people": [
+	#		    {"name": "Ebony Boycott", "hourlyRate": 75.0030, "overtimeRate": 150.0000, "normalHours": 35.0, "overtimeHours": 7.3, "injuryDate": "2016/05/01" },
+	#		    {"name": "Geoff Rainford-Brent", "hourlyRate": 30.1234, "overtimeRate": 60.3456, "normalHours": 25.0, "overtimeHours": 10.7, "injuryDate": "2016/08/04" },
+	#		    {"name": "Meg Gillespie", "hourlyRate": 50.0000, "overtimeRate": 100.0000, "normalHours": 37.5, "overtimeHours": 0.0, "injuryDate": "2015/12/31" },
+	#		    {"name": "Jason Lanning", "hourlyRate": 40.0055, "overtimeRate": 90.9876, "normalHours": 40.0, "overtimeHours": 12.4, "injuryDate": "2013/01/01" }
+	#		]}
+	#
+	# * name - The person's name.
+	#
+	# * hourlyRate - The person's hourly rate of pay, calculated according to PIAWE rules.
+	#
+	# * overtimeRate - The person's overtime rate of pay, calculated according to PIAWE rules.
+	#
+	# * normalHours - The person's normal weekly hours, calculated according to PIAWE rules.
+	#
+	# * overtimeHours - The person's normal weekly overtime hours, calculated according to PIAWE rules.
+	#
+	# * injuryDate - The date of the injury that caused the person to cease work.
+	#
+  # ==== Rule Hash
+  #
+  # A rule hash it a Ruby hash that has has the following format:
+  #
+	#   {"rules":[
+	#     {"applicableWeeks": "1-26", "percentagePayable": 90, "overtimeIncluded": true},
+	#     {"applicableWeeks": "27-52", "percentagePayable": 80, "overtimeIncluded": true},
+	#     {"applicableWeeks": "53-79", "percentagePayable": 70, "overtimeIncluded": true},
+	#     {"applicableWeeks": "80-104", "percentagePayable": 60, "overtimeIncluded": false},
+	#     {"applicableWeeks": "105+", "percentagePayable": 10, "overtimeIncluded": false}
+	#   ]}
+	#
+	# * applicableWeeks - A String that indicates the range of injury weeks during which the rule applies - Week 1 starts at the day of the injury, and Week 2 starts on the 7th day after the injury, and so on.  It can have two formats: either a start week and end week joined by a dash, or a start week followed by a plus sign, which indicates the rule should apply to all later weeks as well. The first rule must have a start week of 1, the last rule must use the plus sign syntax, and all intervening rules must have a start week that is one greater than the end week of the preceeding rule.
+	#
+	# * percentagePayable - A Numeric that indicates the percentage of Average Weekly Earnings that are paid when this rule applies.
+	#
+	# * overtimeIncluded - A TrueClass or FalseClass that indicates whether overtime earnings should be considered part of Average Weekly Earnings when this rule applies.
+	def initialize( people_array, rules_array )
+		@rules = Piawe::RuleSet.new rules_array
+		@people = people_array.map { |person_hash| Person.played_by(person_hash) }
+	end # initialize
+
+
+	# Generate a PIAWE report (Ruby Hash format) for the people and rules this Piawe instance encapsulates, as at the specified report date. 
+  #
+  # ==== Parameters
+  #
+  # * +report_date+ - The date for which the report should be generated. Defaults to the current date
+  #
+	def report( report_date=Date.today )
+		{
+			report_date: report_date.strftime("%Y/%m/%d"),
+			report_lines: @people.map { |person| @rules.report_line(person, report_date) }
+		}
+	end # method report
+
+
+
+	role :Person do
+
+		def weeks_since_injury(report_date) # :nodoc:
+			@weeks_since_injury ||= ( report_date - injury_date) / 7 
+		end
+
+
+		def injury_date # :nodoc:
+			@injury_date ||= (
+				self.has_key?("injuryDate") || (raise ArgumentError, "person_hash does not have a key of injuryDate: #{self.inspect}")
+				/^\d{4}\/\d{2}\/\d{2}$/ =~ self["injuryDate"] || (raise ArgumentError, "injury date of #{self["injuryDate"]} is not in yyyy/mm/dd format: #{self.inspect}")
+				result = nil
+				begin
+					result = Date.parse self["injuryDate"]
+				rescue ArgumentError => ex
+					raise ArgumentError, "person_hash has an invalidly formatted injuryDate key: #{self.inspect} }"
+				end
+				result <= Date.today || (raise ArgumentError, "person_hash has an injuryDate value that is in the future: #{self.inspect}")
+				result
+			)
+		end
+
+
+		def name # :nodoc:
+			self.has_key?("name") || (raise ArgumentError, "person_hash does not have a key of name: #{self.inspect}")
+			self["name"] || (raise ArgumentError, "person_hash has a nil value for name key: #{self.inspect}")
+			self["name"]
+		end
+
+
+		def hourly_rate # :nodoc:
+			get_decimal "hourlyRate"
+		end
+
+
+		def overtime_rate # :nodoc:
+			get_decimal "overtimeRate"
+		end
+
+
+		def normal_hours # :nodoc:
+			get_decimal "normalHours"
+		end
+
+
+		def overtime_hours # :nodoc:
+			get_decimal "overtimeHours"
+		end
+
+
+		def get_decimal(key) # :nodoc:
+			self.has_key?(key) || (raise ArgumentError, "person_hash does not have a key of #{key}: #{self.inspect}")
+			self[key].is_a?(Numeric) || (raise ArgumentError, "person_hash has a non-numeric value for #{key} key: #{self.inspect}")
+			BigDecimal.new self[key], 15
+		end
+
+
+	end
+
+
+end # class Piawe

data/piawe.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'piawe/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jg_piawe'
+  spec.version       = Piawe::VERSION
+  spec.authors       = ["John Gray"]
+  spec.email         = 'foo@bar.com'
+  spec.date          = '2017-03-08'
+
+  spec.summary       = "PIAWE calculator"
+  spec.description   = "A simple calculator for PIAWE based payments"
+  spec.homepage      = 'http://rubygems.org/gems/jg_piawe'
+  spec.license       = 'GPL-3.0'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_runtime_dependency "role_playing", ["= 0.1.5"]
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: jg_piawe
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- John Gray
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: role_playing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+description: A simple calculator for PIAWE based payments
+email: foo@bar.com
+executables:
+- piawe_report
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".simplecov"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/piawe_report
+- lib/piawe.rb
+- lib/piawe/file_parser.rb
+- lib/piawe/rule_set.rb
+- lib/piawe/version.rb
+- piawe.gemspec
+homepage: http://rubygems.org/gems/jg_piawe
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: PIAWE calculator
+test_files: []