cql 0.3.0 → 1.0.0

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ODIxODczMTZmOTQwODJjMGFjODIwZjE5Zjk2OWJhYzY2YTQ0MzMzNA==
-  data.tar.gz: !binary |-
-    OWMyODEwMzRmOGZkMDlkZGFhNzcyOTQ2OTNlZTViZmQ4OTVhOTk0Nw==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    Yzg2YzE0YjNjZmY1NGMxNDMzY2QxNDFiZTMxOTU5NDE5NDNhMmZlMTJkY2Vi
-    YzRiNjQwMzk2OGYyNjYzNTg1NzM3YmM3M2M1OTBhNzM2ZWY1NDZjN2I2N2Mx
-    MjYzMmYyNTA2NzJiNzExOTk2MmFlMzI4NmQ3ZWFkNzliYTQwNzI=
-  data.tar.gz: !binary |-
-    NDg5MGNjNmYxZGRkODE0ODNmNmU1M2MyNjlkY2RhOGE0NDNjZDhiZjExYzhh
-    YTAzNzE3YTc4NDU4ZDg1MGNkM2M0MGMxYmFhMGIyN2I5YjcxYWViOGQ1YmM5
-    Nzk0ZTZlN2UyNmIzZGUzNTM4NWI5MDQxMDk0M2Y4MjI3ZjcwZjM=

data/lib/dsl.rb

@@ -1,111 +0,0 @@
-require File.dirname(__FILE__) + "/map_reduce"
-module CQL
-  module Dsl
-    #Select clause
-    def select *what
-      @what = what
-    end
-
-    (CQL::QUERY_VALUES + %w(all step_lines examples)).each do |method_name|
-      define_method(method_name) { |*args|
-        return method_name if args.size == 0
-        {method_name=>args}
-      }
-    end
-
-    alias :everything :all
-    alias :complete :all
-
-    def name *args
-      return 'name' if args.size == 0
-      CQL::NameFilter.new args[0]
-    end
-
-    def line *args
-      return 'line' if args.size == 0
-      CQL::LineFilter.new args.first
-    end
-
-    #from clause
-    def from where
-      @from = where
-      @data
-    end
-
-    %w(features scenario_outlines scenarios).each do |method_name|
-      define_method(method_name) { |*args|
-        return method_name if args.size == 0
-        {method_name=>args}
-      }
-    end
-
-    #with clause
-    def with filter
-      @data = filter.execute(@data)
-    end
-
-    class Comparison
-      attr_accessor :op, :amount
-
-      def initialize op, amount
-        @op = op
-        @amount = amount
-      end
-
-      def operator
-        {"lt"=>'<', 'lte'=>'<=', 'gt'=>'>', 'gte'=>'>='}[@op]
-      end
-
-    end
-
-    def tc comparison
-      if @from == 'features'
-        FeatureTagCountFilter.new('tc', comparison)
-      else
-        SsoTagCountFilter.new 'tc', comparison
-      end
-    end
-
-    def lc comparison
-      CQL::SsoLineCountFilter.new('lc', comparison)
-    end
-
-    def ssoc comparison
-      Filter.new('ssoc', comparison)
-    end
-
-    def sc comparison
-      Filter.new('sc', comparison)
-    end
-
-    def soc comparison
-      Filter.new('soc', comparison)
-    end
-
-    def gt amount
-      Comparison.new 'gt', amount
-    end
-
-    def gte amount
-      Comparison.new 'gte', amount
-    end
-
-    def lt amount
-      Comparison.new 'lt', amount
-    end
-
-    def lte amount
-      Comparison.new 'lte', amount
-    end
-
-    def tags *tags
-      return "tags" if tags.size == 0
-      if @from == 'features'
-        FeatureTagFilter.new tags
-      else
-        CQL::SsoTagFilter.new tags
-      end
-    end
-
-  end
-end

data/lib/feature_filters.rb

@@ -1,89 +0,0 @@
-module CQL
-  class NameFilter
-    attr_reader :name
-
-    def initialize name
-      @name = name
-    end
-
-    def execute input
-      if name.class == String
-        input = input.find_all { |feature| feature.name == name }
-      elsif name.class == Regexp
-        input = input.find_all { |feature| feature.name =~ name }
-      end
-
-      input
-    end
-  end
-
-  class Filter
-    attr_reader :type, :comparison
-
-    def initialize type, comparison
-      @type = type
-      @comparison = comparison
-    end
-
-    def full_type
-      {"sc"=>["Scenario"], "soc"=>["Scenario Outline"], "ssoc"=>["Scenario", "Scenario Outline"]}[@type]
-    end
-
-    def execute input
-      input.find_all do |feature|
-        size = feature.tests.find_all { |test|
-
-          element_class = test.class.to_s[/::.*$/].gsub(':', '')
-
-          case element_class
-            when 'Outline'
-              element_class = 'Scenario Outline'
-            when 'Scenario'
-              element_class = 'Scenario'
-            else
-              raise "Unknown class: #{element_class}"
-          end
-
-          full_type.include?(element_class)
-        }.size
-
-        size.send(comparison.operator, comparison.amount)
-      end
-    end
-
-  end
-
-  class FeatureTagCountFilter < Filter
-    def execute input
-      input.find_all do |feature|
-        feature.tags && feature.tags.size.send(comparison.operator, comparison.amount)
-      end
-    end
-  end
-
-  class TagFilter
-    attr_reader :tags
-
-    def initialize tags
-      @tags = tags
-    end
-
-    def has_tags given, search
-      return false if given == nil
-      search.count do |tag_for_search|
-        given.map { |t| t["name"] }.include?(tag_for_search)
-      end ==search.size
-    end
-  end
-
-  class FeatureTagFilter < TagFilter
-    def initialize tags
-      super tags
-    end
-
-    def execute input
-      input.find_all { |feature| has_tags feature.raw_element['tags'], tags }
-    end
-  end
-
-end

data/lib/map_reduce.rb

@@ -1,104 +0,0 @@
-require_relative "dsl"
-require_relative "feature_filters"
-require_relative "sso_filters"
-
-require 'set'
-
-module CQL
-  QUERY_VALUES = %w(name uri line description type steps id tags examples)
-
-  class MapReduce
-
-    def self.name(data)
-      data = data.dup
-      data.map { |element| element.name }
-    end
-
-    def self.uri(data)
-      data = data.dup
-      data.map { |element| element.parent_element.path }
-    end
-
-    def self.description(data)
-      data = data.dup
-      data.map { |element| element.description.join("\n") }
-    end
-
-    def self.tags(data)
-      data = data.dup
-      data.map { |element| element.raw_element['tags'] }
-    end
-
-    def self.line(data)
-      data = data.dup
-      data.map { |element| element.source_line }
-    end
-
-    def self.examples(data)
-      data = data.dup
-      data.map { |element| element.examples.collect { |example| example.raw_element } }
-    end
-
-    def self.steps(data)
-      data = data.dup
-      data.map { |element| element.steps.collect { |step| step.raw_element } }
-    end
-
-    def self.type(data)
-      data = data.dup
-      data.map do |element|
-        element_class = element.class.to_s[/::.*$/].gsub(':', '')
-
-        case element_class
-          when 'Outline'
-            type = 'scenario_outline'
-          when 'Scenario'
-            type = 'scenario'
-          else
-            raise "Unknown class: #{element_class}"
-        end
-
-        type
-      end
-    end
-
-    def self.id(data)
-      data = data.dup
-      data.map { |element| element.raw_element['id'] }
-    end
-
-    %w(all everything complete).each do |method_name|
-      define_singleton_method(method_name) { |input| input }
-    end
-
-    def self.step_lines input
-      input = [input] if input.class != Array
-      steps(input).map do |scen|
-        scen.map { |line| line['keyword'] + line['name'] }
-      end
-    end
-
-    def self.feature_children input, args
-      results = []
-
-      input.each do |feature|
-        feature.contains.each do |element|
-
-          case args['what']
-            when 'scenario'
-              results.push element if element.class.to_s[/::.*$/].gsub(':', '') == 'Scenario'
-            when 'scenario_outline'
-              results.push element if element.class.to_s[/::.*$/].gsub(':', '') == 'Outline'
-            else
-              raise "Unknown type: #{args['what']}"
-          end
-
-        end
-      end
-
-      results
-    end
-
-  end
-
-end

data/lib/sso_filters.rb

@@ -1,82 +0,0 @@
-module CQL
-
-  class SsoTagCountFilter < Filter
-    def execute input
-      input.each_with_index do |feature, index|
-        filtered_elements= feature.tests.find_all do |sso|
-          sso.tags.size.send(comparison.operator, comparison.amount)
-        end
-
-        input[index].tests = filtered_elements
-      end
-
-      input
-    end
-  end
-
-  class SsoTagFilter < TagFilter
-    def execute input
-      input.each_with_index do |feature, index|
-        features_with_contents_filtered = feature.tests.find_all do |sso|
-          has_tags(sso.raw_element['tags'], tags)
-        end
-
-        input[index].tests = features_with_contents_filtered
-      end
-
-      input
-    end
-  end
-
-  class SsoLineCountFilter < Filter
-    def execute input
-      input.each_with_index do |feature, index|
-        filtered_elements = feature.tests.find_all do |sso|
-          sso.steps.size.send(comparison.operator, comparison.amount)
-        end
-
-        input[index].tests = filtered_elements
-      end
-
-      input
-    end
-  end
-
-  class LineFilter
-    attr_reader :line
-
-    def initialize line
-      @line = line
-    end
-
-    def execute input
-      input.each_with_index do |feature, index|
-        filtered_elements = feature.tests.find_all do |sso|
-          raw_step_lines = sso.steps.map { |sl| sl.base }
-          result = nil
-
-          if line.class == String
-            result = raw_step_lines.include? line
-          elsif line.class == Regexp
-            result = filter_by_regexp(raw_step_lines)
-          end
-
-          result
-        end
-
-        input[index].tests = filtered_elements
-      end
-    end
-
-    def filter_by_regexp(raw_step_lines)
-      result = raw_step_lines.find { |l| l =~line }
-      if result.class == String
-        result = result.size > 0
-      else
-        result = false
-      end
-      result
-    end
-  end
-
-end