fitting 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56f3f0f488cdee6be583ce31472dafab117afb58
-  data.tar.gz: 3e082349195724b60655350d648b726420118bdb
+  metadata.gz: 7d1997d69b352bcdbba93f00c3e50cba25eb4d70
+  data.tar.gz: c39ea9c0cc9ee2c81d506f83c4f85ab614accb4f
 SHA512:
-  metadata.gz: b0084485379e61b738e6afb271fcfd6817dc10e6884ee16282b7186a4e342a0612318223c3e80abc932e711dd376d84a54a4c91ace4ad7d5561327e38e78344e
-  data.tar.gz: 0440e437b56e83c8450408b3ac0fb9dba4217c57960e736d73a55e715e8a7fd7ac5e882a30d674002655b4f39acddd59690c013c30e316095faf22776de4bcd9
+  metadata.gz: 68b687226ff3b178bb8fb774cc011a4c5a285ee13b246362dab05e15a71b18bbfee1b406a7f9a88494c8bd7a786fad4b43373382fa93495d3d86dc9cffa37402
+  data.tar.gz: 74928dc7e164fdad8fd68bc96fcf88753665cb49024fbb56db5bf68f706385f8a492254c4b1efec7960fbd6c0188a5264faca35af20e015bc2b78667fd272898

data/README.md

@@ -78,6 +78,10 @@ config.white_list = {
 
 Empty array `[]` means all methods.
 
+### create_report_with_name
+
+Create report with name.
+
 ## Report
 
 Autogenerate `report_request_by_response.yaml` and `report_response.yaml reports`.

data/lib/fitting.rb

@@ -1,13 +1,11 @@
 require 'fitting/version'
 require 'fitting/configuration'
-require 'fitting/documentation/response/route'
-require 'fitting/documentation/response/routes'
-require 'fitting/documentation/request/route'
-require 'fitting/storage/responses'
 require 'fitting/storage/documentation'
 require 'fitting/storage/skip'
 require 'fitting/matchers/response_matcher'
 require 'rspec/core'
+require 'fitting/statistics'
+require 'fitting/documentation'
 
 ERROR_EXIT_CODE = 1
 
@@ -34,28 +32,17 @@ module RSpec
 
         return returned_exit_code if Fitting::Storage::Skip.get
 
-        responses_routes = Fitting::Documentation::Response::Routes.new(
-          Fitting::Storage::Documentation.hash,
-          Fitting.configuration.white_list
-        )
-
-        puts '[Black list]'
-        response_routes_black = Fitting::Documentation::Response::Route.new(
-          Fitting::Storage::Responses.all,
-          responses_routes.black
-        )
-        response_routes_black.statistics
-
-        puts '[White list]'
-        response_routes_white = Fitting::Documentation::Response::Route.new(
-          Fitting::Storage::Responses.all,
-          responses_routes.white
-        )
-        response_routes_white.statistics_with_conformity_lists
+        statistics = Fitting::Statistics.new(
+          Fitting::Documentation.new(Fitting.configuration.tomogram, Fitting.configuration.white_list),
+          Fitting::Storage::Responses.all)
+        puts statistics
+        if Fitting.configuration.create_report_with_name
+          statistics.save(Fitting.configuration.create_report_with_name)
+        end
 
         if Fitting.configuration.necessary_fully_implementation_of_responses &&
           returned_exit_code == 0 &&
-          response_routes_white.not_coverage.present?
+          response.not_coverage?
           return ERROR_EXIT_CODE
         end
         returned_exit_code

data/lib/fitting/configuration.rb

@@ -2,7 +2,8 @@ module Fitting
   class Configuration
     attr_accessor :tomogram,
                   :necessary_fully_implementation_of_responses,
-                  :white_list
+                  :white_list,
+                  :create_report_with_name
 
     def initialize
       @necessary_fully_implementation_of_responses = true

data/lib/fitting/documentation.rb

@@ -0,0 +1,48 @@
+require 'multi_json'
+
+module Fitting
+  class Documentation
+    def initialize(tomogram, white_list)
+      @tomogram = tomogram
+      @white_list = white_list
+    end
+
+    def black
+      if @white_list
+        all.select do |response|
+          data = response.split(' ')
+          data[1] && !@white_list[data[1]] || (@white_list[data[1]] != [] && !@white_list[data[1]].include?(data[0]))
+        end
+      else
+        []
+      end
+    end
+
+    def white
+      if @white_list
+        all.select do |response|
+          data = response.split(' ')
+          data[1] && @white_list[data[1]] && (@white_list[data[1]] == [] || @white_list[data[1]].include?(data[0]))
+        end
+      else
+        all
+      end
+    end
+
+    def all
+      @all ||= MultiJson.load(@tomogram).inject([]) do |routes, request|
+        request['responses'].inject({}) do |responses, response|
+          responses[response['status']] ||= 0
+          responses[response['status']] += 1
+          responses
+        end.map do |status, indexes|
+          indexes.times do |index|
+            route = "#{request['method']}\t#{request['path']} #{status} #{index}"
+            routes.push(route)
+          end
+        end
+        routes
+      end.uniq
+    end
+  end
+end

data/lib/fitting/route.rb

@@ -0,0 +1,21 @@
+require 'fitting/route/coverage'
+require 'fitting/route/requests'
+require 'fitting/route/responses'
+
+module Fitting
+  class Route
+    def initialize(all_responses, routes)
+      coverage = Fitting::Route::Coverage.new(all_responses, routes)
+      @requests = Fitting::Route::Requests.new(coverage)
+      @responses = Fitting::Route::Responses.new(routes, coverage)
+    end
+
+    def statistics
+      [@requests.statistics, @responses.statistics].join("\n\n")
+    end
+
+    def statistics_with_conformity_lists
+      [@requests.conformity_lists, statistics].join("\n\n")
+    end
+  end
+end

data/lib/fitting/route/coverage.rb

@@ -0,0 +1,38 @@
+require 'multi_json'
+module Fitting
+  class Route
+    class Coverage
+      def initialize(coverage_responses, responses_routes)
+        @coverage_responses = coverage_responses
+        @responses_routes = responses_routes
+      end
+
+      def coverage
+        @coverage ||= @responses_routes - (@responses_routes - full_coverage)
+      end
+
+      def not_coverage
+        @not_coverage ||= @responses_routes - coverage
+      end
+
+      def cover_ratio
+        @cover_ratio ||= (coverage.size.to_f / @responses_routes.size.to_f * 100.0).round(2)
+      end
+
+      def to_hash
+        {
+          'coverage' => coverage,
+          'not coverage' => not_coverage
+        }
+      end
+
+      private
+
+      def full_coverage
+        @coverage_responses.map do |response|
+          response.route if response.documented? && response.valid?
+        end.compact.uniq
+      end
+    end
+  end
+end

data/lib/fitting/route/requests.rb

@@ -0,0 +1,148 @@
+require 'multi_json'
+
+module Fitting
+  class Route
+    class Requests
+      def initialize(coverage)
+        @coverage = coverage
+      end
+
+      def coverage_statistic
+        stat = {}
+        @coverage.coverage.map do |route|
+          macro_key = route.split(' ')[0..1].join(' ')
+          micro_key = route.split(' ')[2..3].join(' ')
+          stat[macro_key] ||= {}
+          stat[macro_key]['cover'] ||= []
+          stat[macro_key]['not_cover'] ||= []
+          stat[macro_key]['cover'].push(micro_key)
+          stat[macro_key]['all'] ||= []
+          stat[macro_key]['all'].push("✔ #{route.split(' ')[2..3].join(' ')}")
+        end
+        @coverage.not_coverage.map do |route|
+          macro_key = route.split(' ')[0..1].join(' ')
+          micro_key = route.split(' ')[2..3].join(' ')
+          stat[macro_key] ||= {}
+          stat[macro_key]['cover'] ||= []
+          stat[macro_key]['not_cover'] ||= []
+          stat[macro_key]['not_cover'].push(micro_key)
+          stat[macro_key]['all'] ||= []
+          stat[macro_key]['all'].push("✖ #{route.split(' ')[2..3].join(' ')}")
+        end
+        @stat = stat.inject(
+          {
+            'full cover' => [],
+            'partial cover' => [],
+            'no cover' => []
+          }
+        ) do |res, date|
+          ratio = date.last['cover_ratio'] =
+            (date.last['cover'].size.to_f /
+              (date.last['cover'].size + date.last['not_cover'].size).to_f * 100.0).round(2)
+          info = {date.first => {
+            'cover' => date.last['cover'],
+            'not_cover' => date.last['not_cover'],
+            'all' => "#{beautiful_output(date.last)}"
+          }}
+          if ratio == 100.0
+            res['full cover'].push(info)
+          elsif ratio == 0.0
+            res['no cover'].push(info)
+          else
+            res['partial cover'].push(info)
+          end
+          path = date.first.split(' ')[1].size / 8
+          @max ||= 1
+          if path.size > @max
+            @max = path.size
+          end
+          res
+        end
+      end
+
+      def to_hash
+        @stat ||= coverage_statistic
+      end
+
+      def fully_implemented
+        @stat ||= coverage_statistic
+        @fully_implemented ||= @stat['full cover'].map do |response|
+          "#{response.first.to_a.first.split(' ').join("\t")}#{"\t"*(@max-response.first.to_a.first.split(' ')[1].size/8)}#{response.first.to_a.last['all']}"
+        end.sort do |first, second|
+          first.split("\t")[1] <=> second.split("\t")[1]
+        end
+      end
+
+      def partially_implemented
+        @stat ||= coverage_statistic
+        @partially_implemented ||= @stat['partial cover'].map do |response|
+          "#{response.first.to_a.first.split(' ').join("\t")}#{"\t"*(@max-response.first.to_a.first.split(' ')[1].size/8)}#{response.first.to_a.last['all']}"
+        end.sort do |first, second|
+          first.split("\t")[1] <=> second.split("\t")[1]
+        end
+      end
+
+      def no_implemented
+        @stat ||= coverage_statistic
+        @no_implemented ||= @stat['no cover'].map do |response|
+          "#{response.first.to_a.first.split(' ').join("\t")}#{"\t"*(@max-response.first.to_a.first.split(' ')[1].size/8)}#{response.first.to_a.last['all']}"
+        end.sort do |first, second|
+          first.split("\t")[1] <=> second.split("\t")[1]
+        end
+      end
+
+      def statistics
+        @stat ||= coverage_statistic
+        full_count = @stat.to_hash['full cover'].size
+        part_count = @stat.to_hash['partial cover'].size
+        no_count = @stat.to_hash['no cover'].size
+        total_count = full_count + part_count + no_count
+        full_percentage = (full_count.to_f / total_count.to_f * 100.0).round(2)
+        part_percentage = (part_count.to_f / total_count.to_f * 100.0).round(2)
+        no_percentage = (no_count.to_f / total_count.to_f * 100.0).round(2)
+
+        [
+          "API requests with fully implemented responses: #{full_count} (#{full_percentage}% of #{total_count}).",
+          "API requests with partially implemented responses: #{part_count} (#{part_percentage}% of #{total_count}).",
+          "API requests with no implemented responses: #{no_count} (#{no_percentage}% of #{total_count})."
+        ].join("\n")
+      end
+
+      def conformity_lists
+        @stat ||= coverage_statistic
+        fully_implemented ||= self.fully_implemented.join("\n")
+        partially_implemented ||= self.partially_implemented.join("\n")
+        no_implemented ||= self.no_implemented.join("\n")
+
+        [
+          ['Fully conforming requests:', fully_implemented].join("\n"),
+          ['Partially conforming requests:', partially_implemented].join("\n"),
+          ['Non-conforming requests:', no_implemented].join("\n")
+        ].join("\n\n")
+      end
+
+      private
+
+      def beautiful_output(hash)
+        methods = {}
+        res = []
+        hash['cover'].map do |response|
+          method, index = response.split(' ')
+          methods[method] ||= []
+          methods[method][index.to_i] = {'method' => method, 'cover' => true}
+        end
+        hash['not_cover'].map do |response|
+          method, index = response.split(' ')
+          methods[method] ||= []
+          methods[method][index.to_i] = {'method' => method, 'cover' => false}
+        end
+        methods.map do |method|
+          method.last.size.times do |index|
+            res.push("#{method.last[index]['cover'] ? '✔' : '✖'} #{method.first}")
+          end
+        end
+        res.join(' ')
+      end
+    end
+  end
+end

data/lib/fitting/route/responses.rb

@@ -0,0 +1,23 @@
+module Fitting
+  class Route
+    class Responses
+      def initialize(routes, coverage)
+        @routes = routes
+        @coverage = coverage
+      end
+
+      def statistics
+        valid_count = @coverage.coverage.size
+        valid_percentage = @coverage.cover_ratio
+        total_count = @routes.size
+        invalid_count = @coverage.not_coverage.size
+        invalid_percentage = (100.0 - @coverage.cover_ratio).round(2)
+
+        [
+          "API responses conforming to the blueprint: #{valid_count} (#{valid_percentage}% of #{total_count}).",
+          "API responses with validation errors or untested: #{invalid_count} (#{invalid_percentage}% of #{total_count})."
+        ].join("\n")
+      end
+    end
+  end
+end

data/lib/fitting/statistics.rb

@@ -0,0 +1,31 @@
+require 'fitting/route'
+
+module Fitting
+  class Statistics
+    def initialize(documentation, all_responses)
+      @documentation = documentation
+      @black_route = Fitting::Route.new(all_responses, @documentation.black)
+      @white_route = Fitting::Route.new(all_responses, @documentation.white)
+    end
+
+    def not_coverage?
+      @white_route.not_coverage.present?
+    end
+
+    def save(name)
+      File.open(name, 'w') { |file| file.write(to_s) }
+    end
+
+    def to_s
+      if @documentation.black.any?
+        [
+          ['[Black list]', @black_route.statistics].join("\n"),
+          ['[White list]', @white_route.statistics_with_conformity_lists].join("\n"),
+          ""
+        ].join("\n\n")
+      else
+        [@white_route.statistics_with_conformity_lists, "\n\n"].join
+      end
+    end
+  end
+end

data/lib/fitting/storage/documentation.rb

@@ -1,15 +1,12 @@
 require 'tomogram_routing'
+require 'fitting/configuration'
 
 module Fitting
   module Storage
     module Documentation
       class << self
         def tomogram
-          @tomogram ||= TomogramRouting::Tomogram.craft(hash)
-        end
-
-        def hash
-          Fitting.configuration.tomogram
+          @tomogram ||= TomogramRouting::Tomogram.craft(Fitting.configuration.tomogram)
         end
       end
     end

data/lib/fitting/version.rb

@@ -1,3 +1,3 @@
 module Fitting
-  VERSION = '1.4.0'.freeze
+  VERSION = '1.5.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fitting
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - d.efimov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-10 00:00:00.000000000 Z
+date: 2017-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -212,12 +212,15 @@ files:
 - fitting.gemspec
 - lib/fitting.rb
 - lib/fitting/configuration.rb
-- lib/fitting/documentation/request/route.rb
-- lib/fitting/documentation/response/route.rb
-- lib/fitting/documentation/response/routes.rb
+- lib/fitting/documentation.rb
 - lib/fitting/matchers/response_matcher.rb
 - lib/fitting/request.rb
 - lib/fitting/response.rb
+- lib/fitting/route.rb
+- lib/fitting/route/coverage.rb
+- lib/fitting/route/requests.rb
+- lib/fitting/route/responses.rb
+- lib/fitting/statistics.rb
 - lib/fitting/storage/documentation.rb
 - lib/fitting/storage/responses.rb
 - lib/fitting/storage/skip.rb

data/lib/fitting/documentation/request/route.rb

@@ -1,143 +0,0 @@
-require 'multi_json'
-
-module Fitting
-  module Documentation
-    module Request
-      class Route
-        def initialize(response_routes)
-          @response_routes = response_routes
-        end
-
-        def coverage_statistic
-          stat = {}
-          @response_routes.coverage.map do |route|
-            macro_key = route.split(' ')[0..1].join(' ')
-            micro_key = route.split(' ')[2..3].join(' ')
-            stat[macro_key] ||= {}
-            stat[macro_key]['cover'] ||= []
-            stat[macro_key]['not_cover'] ||= []
-            stat[macro_key]['cover'].push(micro_key)
-            stat[macro_key]['all'] ||= []
-            stat[macro_key]['all'].push("✔ #{route.split(' ')[2..3].join(' ')}")
-          end
-          @response_routes.not_coverage.map do |route|
-            macro_key = route.split(' ')[0..1].join(' ')
-            micro_key = route.split(' ')[2..3].join(' ')
-            stat[macro_key] ||= {}
-            stat[macro_key]['cover'] ||= []
-            stat[macro_key]['not_cover'] ||= []
-            stat[macro_key]['not_cover'].push(micro_key)
-            stat[macro_key]['all'] ||= []
-            stat[macro_key]['all'].push("✖ #{route.split(' ')[2..3].join(' ')}")
-          end
-          @stat = stat.inject(
-            {
-              'full cover' => [],
-              'partial cover' => [],
-              'no cover' => []
-            }
-          ) do |res, date|
-            ratio = date.last['cover_ratio'] =
-              (date.last['cover'].size.to_f /
-                (date.last['cover'].size + date.last['not_cover'].size).to_f * 100.0).round(2)
-            info = {date.first => {
-              'cover' => date.last['cover'],
-              'not_cover' => date.last['not_cover'],
-              'all' => "#{beautiful_output(date.last)}"
-            }}
-            if ratio == 100.0
-              res['full cover'].push(info)
-            elsif ratio == 0.0
-              res['no cover'].push(info)
-            else
-              res['partial cover'].push(info)
-            end
-            path = date.first.split(' ')[1].size / 8
-            @max ||= 1
-            if path.size > @max
-              @max = path.size
-            end
-            res
-          end
-        end
-
-        def to_hash
-          @stat ||= coverage_statistic
-        end
-
-        def fully_implemented
-          @stat ||= coverage_statistic
-          @fully_implemented ||= @stat['full cover'].map do |response|
-            "#{response.first.to_a.first.split(' ').join("\t")}#{"\t"*(@max-response.first.to_a.first.split(' ')[1].size/8)}#{response.first.to_a.last['all']}"
-          end.sort do |first, second|
-            first.split("\t")[1] <=> second.split("\t")[1]
-          end
-        end
-
-        def partially_implemented
-          @stat ||= coverage_statistic
-          @partially_implemented ||= @stat['partial cover'].map do |response|
-            "#{response.first.to_a.first.split(' ').join("\t")}#{"\t"*(@max-response.first.to_a.first.split(' ')[1].size/8)}#{response.first.to_a.last['all']}"
-          end.sort do |first, second|
-            first.split("\t")[1] <=> second.split("\t")[1]
-          end
-        end
-
-        def no_implemented
-          @stat ||= coverage_statistic
-          @no_implemented ||= @stat['no cover'].map do |response|
-            "#{response.first.to_a.first.split(' ').join("\t")}#{"\t"*(@max-response.first.to_a.first.split(' ')[1].size/8)}#{response.first.to_a.last['all']}"
-          end.sort do |first, second|
-            first.split("\t")[1] <=> second.split("\t")[1]
-          end
-        end
-
-        def conformity_lists
-          puts "Fully conforming requests: \n#{fully_implemented.join("\n")}"
-          puts
-          puts "Partially conforming requests: \n#{partially_implemented.join("\n")}"
-          puts
-          puts "Non-conforming requests: \n#{no_implemented.join("\n")}"
-          puts
-        end
-
-        def statistics
-          full_count = to_hash['full cover'].size
-          part_count = to_hash['partial cover'].size
-          no_count = to_hash['no cover'].size
-          total_count = full_count + part_count + no_count
-          full_percentage = (full_count.to_f / total_count.to_f * 100.0).round(2)
-          part_percentage = (part_count.to_f / total_count.to_f * 100.0).round(2)
-          no_percentage = (no_count.to_f / total_count.to_f * 100.0).round(2)
-          puts "API requests with fully implemented responses: #{full_count} (#{full_percentage}% of #{total_count})."
-          puts "API requests with partially implemented responses: #{part_count} (#{part_percentage}% of #{total_count})."
-          puts "API requests with no implemented responses: #{no_count} (#{no_percentage}% of #{total_count})."
-          puts
-        end
-
-        private
-
-        def beautiful_output(hash)
-          methods = {}
-          res = []
-          hash['cover'].map do |response|
-            method, index = response.split(' ')
-            methods[method] ||= []
-            methods[method][index.to_i] = {'method' => method, 'cover' => true}
-          end
-          hash['not_cover'].map do |response|
-            method, index = response.split(' ')
-            methods[method] ||= []
-            methods[method][index.to_i] = {'method' => method, 'cover' => false}
-          end
-          methods.map do |method|
-            method.last.size.times do |index|
-              res.push("#{method.last[index]['cover'] ? '✔' : '✖'} #{method.first}")
-            end
-          end
-          res.join(' ')
-        end
-      end
-    end
-  end
-end

data/lib/fitting/documentation/response/route.rb

@@ -1,62 +0,0 @@
-require 'multi_json'
-require 'fitting/documentation/request/route'
-
-module Fitting
-  module Documentation
-    module Response
-      class Route
-        def initialize(coverage_responses, responses_routes)
-          @coverage_responses = coverage_responses
-          @responses_routes = responses_routes
-        end
-
-        def coverage
-          @coverage ||= @responses_routes - (@responses_routes - full_coverage)
-        end
-
-        def not_coverage
-          @not_coverage ||= @responses_routes - coverage
-        end
-
-        def cover_ratio
-          @cover_ratio ||= (coverage.size.to_f / @responses_routes.size.to_f * 100.0).round(2)
-        end
-
-        def to_hash
-          {
-            'coverage' => coverage,
-            'not coverage' => not_coverage
-          }
-        end
-
-        def statistics_with_conformity_lists
-          @request_routes ||= Fitting::Documentation::Request::Route.new(self)
-          @request_routes.conformity_lists
-          statistics
-        end
-
-        def statistics
-          @request_routes ||= Fitting::Documentation::Request::Route.new(self)
-          @request_routes.statistics
-
-          valid_count = coverage.size
-          valid_percentage = cover_ratio
-          total_count = @responses_routes.size
-          invalid_count = not_coverage.size
-          invalid_percentage = 100.0 - cover_ratio
-          puts "API responses conforming to the blueprint: #{valid_count} (#{valid_percentage}% of #{total_count})."
-          puts "API responses with validation errors or untested: #{invalid_count} (#{invalid_percentage}% of #{total_count})."
-          puts
-        end
-
-        private
-
-        def full_coverage
-          @coverage_responses.map do |response|
-            response.route if response.documented? && response.valid?
-          end.compact.uniq
-        end
-      end
-    end
-  end
-end

data/lib/fitting/documentation/response/routes.rb

@@ -1,53 +0,0 @@
-require 'multi_json'
-require 'fitting/documentation/request/route'
-
-module Fitting
-  module Documentation
-    module Response
-      class Routes
-        def initialize(tomogram, white_list)
-          @tomogram = tomogram
-          @white_list = white_list
-        end
-
-        def black
-          if @white_list
-            all.select do |response|
-              data = response.split(' ')
-              data[1] && !@white_list[data[1]] || (@white_list[data[1]] != [] && !@white_list[data[1]].include?(data[0]))
-            end
-          else
-            []
-          end
-        end
-
-        def white
-          if @white_list
-            all.select do |response|
-              data = response.split(' ')
-              data[1] && @white_list[data[1]] && (@white_list[data[1]] == [] || @white_list[data[1]].include?(data[0]))
-            end
-          else
-            all
-          end
-        end
-
-        def all
-          @all ||= MultiJson.load(@tomogram).inject([]) do |routes, request|
-            request['responses'].inject({}) do |responses, response|
-              responses[response['status']] ||= 0
-              responses[response['status']] += 1
-              responses
-            end.map do |status, indexes|
-              indexes.times do |index|
-                route = "#{request['method']}\t#{request['path']} #{status} #{index}"
-                routes.push(route)
-              end
-            end
-            routes
-          end.uniq
-        end
-      end
-    end
-  end
-end