cql 0.3.0 → 1.0.0

data/lib/cql.rb

@@ -1,5 +1,9 @@
+if RUBY_VERSION < '1.9.2'
+  require 'backports/1.9.2/array/rotate'
+end
+
 require 'cuke_modeler'
-require File.dirname(__FILE__) + "/dsl"
+require 'cql/dsl'
 
 module CQL
 
@@ -7,65 +11,113 @@ module CQL
     include Dsl
     attr_reader :data, :what
 
-    def format_to_ary_of_hsh data
-      result = Array.new(data.size).map { |e| {} }
+    def format_data data
+      Array.new.tap do |result_array|
+        data.each do |element|
+          result_array << Hash.new.tap do |result|
+            @what.each_with_index do |attribute, index|
+              key = determine_key(attribute, index)
+              value = determine_value(element, attribute, index)
 
-      @what.each do |w|
-        CQL::MapReduce.send(w, data).each_with_index do |e, i|
-          if e.class.to_s =~ /CukeModeler/
-            result[i][w]=e.raw_element
-          else
-            result[i][w]=e
+              result[key] = value
+            end
           end
         end
       end
 
-      result
     end
 
-    def initialize features, &block
-      @data = features
-      @data = self.instance_eval(&block)
+    def initialize(directory, &block)
+      # Set root object
+      @data = directory
 
-      #getting the children of features
-      @data= CQL::MapReduce.feature_children(@data, 'what'=>@from[0, @from.size-1]) if @from != "features"
+      # Populate configurables from DSL block
+      self.instance_eval(&block)
 
-      @data= format_to_ary_of_hsh(@data)
+      # Gather relevant objects from root object and filters
+      @data= CQL::MapReduce.gather_objects(@data, @from, @filters)
+
+      # Extract properties from gathered objects
+      @data= format_output(@data)
     end
-  end
 
 
-  class Repository
-    attr_reader :parsed_feature_files
+    private
 
-    def initialize features_home_dir
-      @parsed_feature_files = collect_feature_models(CukeModeler::Directory.new(features_home_dir))
+
+    def format_output(data)
+      format_data(data)
     end
 
-    def query &block
-      new_repo = Marshal::load(Marshal.dump(parsed_feature_files))
+    def determine_key(attribute, index)
+      key = transform_stuff(@name_transforms, attribute, index) if @name_transforms
 
-      Query.new(new_repo, &block).data
+      key || attribute
     end
 
+    def determine_value(element, attribute, index)
+      original_value = attribute.is_a?(Symbol) ? special_value(element, attribute) : element.send(attribute)
 
-    private
+      if @value_transforms
+        value = transform_stuff(@value_transforms, attribute, index)
+        value = value.call(original_value) if value.is_a?(Proc)
+      end
 
+      value || original_value
+    end
 
-    def collect_feature_models(directory_model)
-      Array.new.tap { |accumulated_features| collect_all_in(:features, directory_model, accumulated_features) }
+    def special_value(element, attribute)
+      # todo - Not sure what other special values to have but this could be expanded upon later.
+      case attribute
+        when :self
+          val = element
+        else
+          # todo - error message?
+      end
+
+      val
     end
 
-    # Recursively gathers all things of the given type found in the passed container.
-    def collect_all_in(type_of_thing, container, accumulated_things)
-      accumulated_things.concat container.send(type_of_thing) if container.respond_to?(type_of_thing)
+    def transform_stuff(transforms, attribute, location)
+      case
+        when transforms.is_a?(Array)
+          value = transforms[location]
+        when transforms.is_a?(Hash)
+          if transforms[attribute]
+            value = transforms[attribute].first
+            transforms[attribute].rotate!
+          end
+        else
+          # todo - add error message
+      end
 
-      if container.respond_to?(:contains)
-        container.contains.each do |child_container|
-          collect_all_in(type_of_thing, child_container, accumulated_things)
-        end
+      value
+    end
+
+  end
+
+
+  class Repository
+
+    def initialize(repository_root)
+      case
+        when repository_root.is_a?(String)
+          @target_directory = CukeModeler::Directory.new(repository_root)
+        when repository_root.is_a?(Class)
+          # todo - stop assuming
+          # Assume valid CukeModeler class for now
+          @target_directory = repository_root
+        else
+          # todo - raise error?
       end
     end
 
+    def query &block
+      # A quick 'deep clone'
+      new_repo = Marshal::load(Marshal.dump(@target_directory))
+
+      Query.new(new_repo, &block).data
+    end
+
   end
 end

data/lib/cql/dsl.rb

@@ -0,0 +1,152 @@
+require 'cql/map_reduce'
+
+module CQL
+  module Dsl
+
+    def method_missing(method_name)
+      method_name.to_s
+    end
+
+    def transform(*attribute_transforms, &block)
+      # todo - Still feels like some as/transform code duplication but I think that it would get too meta if I
+      # reduced it any further. Perhaps change how the transforms are handled so that there doesn't have to be
+      # an array/hash difference in the first place?
+      prep_variable('value_transforms', attribute_transforms) unless @value_transforms
+
+      # todo - what if they pass in a hash transform and a block?
+      attribute_transforms << block if block
+      add_transforms(attribute_transforms, @value_transforms)
+    end
+
+    def as(*name_transforms)
+      prep_variable('name_transforms', name_transforms) unless @name_transforms
+
+      add_transforms(name_transforms, @name_transforms)
+    end
+
+    #Select clause
+    def select *what
+      @what ||= []
+      @what.concat(what)
+    end
+
+    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(*targets)
+      @from ||= []
+
+      # todo - todo test the intermixing of shorthand and full classes as arguments
+      targets.map! { |target| target.is_a?(String) ? determine_class(target) : target }
+
+      @from.concat(targets)
+    end
+
+    #with clause
+    def with(*conditions, &block)
+      @filters ||= []
+
+      @filters << block if block
+      @filters.concat(conditions)
+    end
+
+    class Comparison
+      attr_accessor :operator, :amount
+
+      def initialize operator, amount
+        @operator = operator
+        @amount = amount
+      end
+
+    end
+
+    def tc comparison
+      TagCountFilter.new 'tc', comparison
+    end
+
+    def lc comparison
+      CQL::SsoLineCountFilter.new('lc', comparison)
+    end
+
+    def ssoc comparison
+      TestCountFilter.new([CukeModeler::Scenario, CukeModeler::Outline], comparison)
+    end
+
+    def sc comparison
+      TestCountFilter.new([CukeModeler::Scenario], comparison)
+    end
+
+    def soc comparison
+      TestCountFilter.new([CukeModeler::Outline], comparison)
+    end
+
+    def gt amount
+      Comparison.new '>', amount
+    end
+
+    def gte amount
+      Comparison.new '>=', amount
+    end
+
+    def lt amount
+      Comparison.new '<', amount
+    end
+
+    def lte amount
+      Comparison.new '<=', amount
+    end
+
+    def tags *tags
+      return "tags" if tags.size == 0
+
+      TagFilter.new tags
+    end
+
+    def translate_shorthand(where)
+      where.split('_').map(&:capitalize).join
+    end
+
+    def prep_variable(var_name, transforms)
+      starting_value = transforms.first.is_a?(Hash) ? {} : []
+      instance_variable_set("@#{var_name}".to_sym, starting_value)
+    end
+
+    def add_transforms(new_transforms, transform_set)
+      # todo - accept either array or a hash
+      if new_transforms.first.is_a?(Hash)
+        additional_transforms = new_transforms.first
+
+        additional_transforms.each do |key, value|
+          if transform_set.has_key?(key)
+            transform_set[key] << value
+          else
+            transform_set[key] = [value]
+          end
+        end
+      else
+
+        transform_set.concat(new_transforms)
+      end
+    end
+
+    def determine_class(where)
+      # Translate shorthand Strings to final class
+      where = translate_shorthand(where)
+
+      # Check for exact class match first because it should take precedence
+      return CukeModeler.const_get(where) if CukeModeler.const_defined?(where)
+
+      # Check for pluralization of class match (i.e. remove the final 's')
+      return CukeModeler.const_get(where.chop) if CukeModeler.const_defined?(where.chop)
+    end
+
+  end
+end

data/lib/cql/feature_filters.rb

@@ -0,0 +1,14 @@
+require 'cql/filters'
+
+
+module CQL
+
+  class TestCountFilter < TypeCountFilter
+
+    def type_count(feature)
+      feature.tests.find_all { |test| types.include?(test.class) }.size
+    end
+
+  end
+
+end

data/lib/cql/filters.rb

@@ -0,0 +1,74 @@
+module CQL
+
+  class TagFilter
+    attr_reader :tags
+
+    def initialize tags
+      @tags = tags
+    end
+
+    def has_tags?(object, tags)
+      tags.all? { |tag| object.tags.include?(tag) }
+    end
+
+    def execute objects
+      objects.find_all { |object| has_tags?(object, tags) }
+    end
+
+  end
+
+  class ContentMatchFilter
+    attr_reader :pattern
+
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    def content_match?(content)
+      if pattern.is_a?(String)
+        content.any? { |thing| thing == pattern }
+      elsif pattern.is_a?(Regexp)
+        content.any? { |thing| thing =~ pattern }
+      else
+        # todo - Raise exception?
+        false
+      end
+    end
+
+  end
+
+  class TypeCountFilter
+    attr_reader :types, :comparison
+
+    def initialize types, comparison
+      @types = types
+      @comparison = comparison
+    end
+
+    def execute input
+      input.find_all do |object|
+        type_count(object).send(comparison.operator, comparison.amount)
+      end
+    end
+
+  end
+
+  class NameFilter < ContentMatchFilter
+
+    def execute(input)
+      input.find_all do |object|
+        content_match?([object.name])
+      end
+    end
+
+  end
+
+  class TagCountFilter < TypeCountFilter
+
+    def type_count(test)
+      test.tags.size
+    end
+
+  end
+
+end

data/lib/cql/map_reduce.rb

@@ -0,0 +1,48 @@
+require 'cql/dsl'
+require 'cql/feature_filters'
+require 'cql/sso_filters'
+
+
+module CQL
+
+  class MapReduce
+
+    def self.gather_objects(current_object, target_classes, filters)
+      gathered_objects = Array.new.tap { |gathered_objects| collect_all_in(target_classes, current_object, gathered_objects) }
+
+      if filters
+        filters.each do |filter|
+          if filter.is_a?(Proc)
+            gathered_objects.select!(&filter)
+          else
+            gathered_objects = filter.execute(gathered_objects)
+          end
+        end
+      end
+
+      gathered_objects
+    end
+
+
+    class << self
+
+
+      private
+
+
+      # Recursively gathers all objects of the given class(es) found in the passed object (including itself).
+      def collect_all_in(targeted_classes, current_object, accumulated_objects)
+        accumulated_objects << current_object if targeted_classes.any? { |targeted_class| current_object.is_a?(targeted_class) }
+
+        if current_object.respond_to?(:contains)
+          current_object.contains.each do |child_object|
+            collect_all_in(targeted_classes, child_object, accumulated_objects)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end