gitlab-triage 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d82746964d894d23cf152a4a5fb996e23216355bba6aa639cb6ea339dcf6fd13
-  data.tar.gz: cc931bd1c1e8f4097e3463b4351f426e39b69cbdbb9dc2e4ac7dafd426659de7
+  metadata.gz: 4ab21a6dffa12d92f9321ac3c6d2bc0c92627fad703fceb7ebf68494d8f5b259
+  data.tar.gz: e5868058935e55d70ccadaada8030a8bec92dee6ceeeea2f9996cd60f3823cdf
 SHA512:
-  metadata.gz: 25effb45c3c03772ade06f3c8fee5b69598917a541aaece754fe053fc77f4bf92d8e74739d9cc3fe605ec275df73cc1c2110615b43d8ee0c57cf2fd3db2e8b3e
-  data.tar.gz: 7c40513edecbed3ab28f9fd116fc554bd6a4fc9dfc828d461a2bccfa4d166aa0960385a1865c487c88172f348a62c19e9a0a197b626aba5e8c8ef1ba5bf6109c
+  metadata.gz: a875bebf70cd7dcc2a6c5f064d692535cdf98b664323fb640b22fed7f52ac4d5f49e8b21adb5b4942f626e4f4638d23f3042109ae13c495ae9c732d177e9298f
+  data.tar.gz: 01a627062e23ba73d40be5cc7260a92aa7be9ec30b9fb694585305ae919435174099a701d6045998c03738ee7fd7dcf0cac9ebf821abfea9b4697fd6f8f55e06

data/README.md

@@ -44,7 +44,7 @@ resource_rules:
             interval_type: days
             interval: 5
           state: opened
-          label:
+          labels:
             - No Label
         actions:
           labels:
@@ -89,6 +89,7 @@ Available condition types:
 - [`no_additional_labels` condition](#no-additional-labels-condition)
 - [`author_member` condition](#author-member-condition)
 - [`assignee_member` condition](#assignee-member-condition)
+- [`ruby` condition](#ruby-condition)
 
 ##### Date condition
 
@@ -177,6 +178,71 @@ conditions:
     - feature proposal
 ```
 
+###### Labels over sequences
+
+The name of a label can contain one or more sequence conditions, written
+like `{0..9}`, which means `0`, `1`, `2`, and so on up to `9`. For each
+number, the rule will be duplicated with the new label name.
+
+Example:
+
+```yml
+resource_rules:
+  issues:
+    rules:
+      - name: Add missing ~"missed\-deliverable" label
+        conditions:
+          labels:
+            - missed:{10..11}.{0..1}
+            - deliverable
+        actions:
+          labels:
+            - missed deliverable
+```
+
+Which will be expanded into:
+
+```yml
+resource_rules:
+  issues:
+    rules:
+      - name: Add missing ~"missed\-deliverable" label
+        conditions:
+          labels:
+            - missed:10.0
+            - deliverable
+        actions:
+          labels:
+            - missed deliverable
+
+      - name: Add missing ~"missed\-deliverable" label
+        conditions:
+          labels:
+            - missed:10.1
+            - deliverable
+        actions:
+          labels:
+            - missed deliverable
+
+      - name: Add missing ~"missed\-deliverable" label
+        conditions:
+          labels:
+            - missed:11.0
+            - deliverable
+        actions:
+          labels:
+            - missed deliverable
+
+      - name: Add missing ~"missed\-deliverable" label
+        conditions:
+          labels:
+            - missed:11.1
+            - deliverable
+        actions:
+          labels:
+            - missed deliverable
+```
+
 ##### Forbidden labels condition
 
 Accepts an array of strings. Each element in the array represents the name of a label to filter on.
@@ -251,6 +317,70 @@ conditions:
     source_id: 9970
 ```
 
+##### Ruby condition
+
+This condition allows users to write a Ruby expression to be evaluated for
+each resource. If it evaluates to a truthy value, it satisfies the condition.
+If it evaluates to a falsey value, it does not satisfy the condition.
+
+Accepts a string as the Ruby expression.
+
+Example:
+
+```yml
+conditions:
+  ruby: Date.today > milestone.succ.start_date
+```
+
+In the above example, this describes that we want to act on the resources
+which passed the next active milestone's starting date.
+
+Here `milestone` will return a `Gitlab::Triage::Resource::Milestone` object,
+representing the milestone of the questioning resource. `Milestone#succ` would
+return the next active milestone, based on the `start_date` of all milestones
+along with the representing milestone. If the milestone was coming from a
+project, then it's based on all active milestones in that project. If the
+milestone was coming from a group, then it's based on all active milestones
+in the group.
+
+If we also want to handle some edge cases, for example, a resource might not
+have a milestone, and a milestone might not be active, and there might not
+have a next milestone. We could instead write something like:
+
+```yml
+conditions:
+  ruby: milestone&.active? && milestone&.succ && Date.today > milestone.succ.start_date
+```
+
+This will make it only act on resources which have active milestones and
+there exists next milestone which has already started.
+
+Here's a list of currently available API:
+
+##### API
+
+| Name      | Return type | Description |
+| ----      | ----        | ----        |
+| milestone | Milestone   | The milestone attached to the resource |
+
+##### Methods for `Milestone`
+
+| Method      | Return type | Description |
+| ----        | ----        | ----        |
+| id          | Integer     | The id of the milestone |
+| iid         | Integer     | The iid of the milestone |
+| project_id  | Integer     | The project id of the milestone if available |
+| group_id    | Integer     | The group id of the milestone if available |
+| title       | String      | The title of the milestone |
+| description | String      | The description of the milestone |
+| state       | String      | The state of the milestone. Could be `active` or `closed` |
+| due_date    | Date        | The due date of the milestone. Could be `nil` |
+| start_date  | Date        | The start date of the milestone. Could be `nil` |
+| updated_at  | Time        | The updated timestamp of the milestone |
+| created_at  | Time        | The created timestamp of the milestone |
+| succ        | Milestone   | The next active milestone beside this milestone |
+| active?     | Boolean     | `true` if `state` is `active`; `false` otherwise |
+
 #### Actions field
 
 Used to declare an action to be carried out on a resource if **all** conditions are satisfied.

data/gitlab-triage.gemspec

@@ -26,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'gitlab-styles', '~> 2.1'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'webmock', '~> 3.4'
 end

data/lib/gitlab/triage/api_query_builders/base_query_param_builder.rb

@@ -0,0 +1,18 @@
+module Gitlab
+  module Triage
+    module APIQueryBuilders
+      class BaseQueryParamBuilder
+        attr_reader :param_name, :param_contents
+
+        def initialize(param_name, param_contents)
+          @param_name = param_name
+          @param_contents = param_contents
+        end
+
+        def build_param
+          "&#{param_name}=#{param_content}"
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/api_query_builders/multi_query_param_builder.rb

@@ -0,0 +1,20 @@
+require_relative 'base_query_param_builder'
+
+module Gitlab
+  module Triage
+    module APIQueryBuilders
+      class MultiQueryParamBuilder < BaseQueryParamBuilder
+        attr_reader :separator
+
+        def initialize(param_name, param_contents, separator)
+          @separator = separator
+          super(param_name, param_contents)
+        end
+
+        def param_content
+          param_contents.join(separator)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/api_query_builders/single_query_param_builder.rb

@@ -0,0 +1,13 @@
+require_relative 'base_query_param_builder'
+
+module Gitlab
+  module Triage
+    module APIQueryBuilders
+      class SingleQueryParamBuilder < BaseQueryParamBuilder
+        def param_content
+          param_contents
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/engine.rb

@@ -1,19 +1,21 @@
 require 'active_support/all'
 
-require_relative 'limiters/date_conditions_limiter'
-require_relative 'limiters/votes_conditions_limiter'
-require_relative 'limiters/forbidden_labels_conditions_limiter'
-require_relative 'limiters/no_additional_labels_conditions_limiter'
-require_relative 'limiters/author_member_conditions_limiter'
-require_relative 'limiters/assignee_member_conditions_limiter'
+require_relative 'expand_condition'
+require_relative 'filters/date_conditions_filter'
+require_relative 'filters/votes_conditions_filter'
+require_relative 'filters/forbidden_labels_conditions_filter'
+require_relative 'filters/no_additional_labels_conditions_filter'
+require_relative 'filters/author_member_conditions_filter'
+require_relative 'filters/assignee_member_conditions_filter'
+require_relative 'filters/ruby_conditions_filter'
 require_relative 'command_builders/comment_body_builder'
 require_relative 'command_builders/comment_command_builder'
 require_relative 'command_builders/label_command_builder'
 require_relative 'command_builders/remove_label_command_builder'
 require_relative 'command_builders/cc_command_builder'
 require_relative 'command_builders/status_command_builder'
-require_relative 'filter_builders/single_filter_builder'
-require_relative 'filter_builders/multi_filter_builder'
+require_relative 'api_query_builders/single_query_param_builder'
+require_relative 'api_query_builders/multi_query_param_builder'
 require_relative 'url_builders/url_builder'
 require_relative 'network'
 require_relative 'network_adapters/httparty_adapter'
@@ -42,10 +44,10 @@ module Gitlab
         puts "Performing a dry run.\n\n" if options.dry_run
 
         resource_rules.each do |type, resource|
-          puts Gitlab::Triage::UI.header("Processing rules for #{type}")
+          puts Gitlab::Triage::UI.header("Processing rules for #{type}", char: '-')
           puts
           resource[:rules].each do |rule|
-            puts Gitlab::Triage::UI.header("Processing rule: #{rule[:name]}", char: '~')
+            puts Gitlab::Triage::UI.header("Processing rule: **#{rule[:name]}**", char: '-')
             puts
             process_rule(type, rule)
           end
@@ -87,40 +89,49 @@ module Gitlab
       end
 
       def process_rule(resource_type, rule)
-        # retrieving the resources for every rule is inefficient
-        # however, previous rules may affect those upcoming
-        resources = network.query_api(options.token, build_get_url(resource_type, rule_conditions(rule)))
-        puts "\n\nFound #{resources.count} resources..."
-        puts "Limiting resources..."
-        resources = limit_resources(resources, rule_conditions(rule))
-        puts "Total resource after limiting: #{resources.count} resources"
-        process_resources(resource_type, resources, rule)
+        ExpandCondition.perform(rule_conditions(rule)) do |conditions|
+          # retrieving the resources for every rule is inefficient
+          # however, previous rules may affect those upcoming
+          resources = network.query_api(options.token, build_get_url(resource_type, conditions))
+          puts "\n\n* Found #{resources.count} resources..."
+          print "* Limiting resources..."
+          resources = limit_resources(resources, conditions)
+          puts "\n* Total resource after limiting: #{resources.count} resources"
+          process_resources(resource_type, resources, rule)
+        end
       end
 
       def limit_resources(resources, conditions)
+        net = { host_url: host_url, api_version: api_version, token: options.token, network: network }
+
         resources.select do |resource|
           results = []
-          results << Limiters::DateConditionsLimiter.new(resource, conditions[:date]).calculate if conditions[:date]
-          results << Limiters::VotesConditionsLimiter.new(resource, conditions[:upvotes]).calculate if conditions[:upvotes]
-          results << Limiters::ForbiddenLabelsConditionsLimiter.new(resource, conditions[:forbidden_labels]).calculate if conditions[:forbidden_labels]
-          results << Limiters::NoAdditionalLabelsConditionsLimiter.new(resource, conditions.fetch(:labels) { [] }).calculate if conditions[:no_additional_labels]
-          results << Limiters::AuthorMemberConditionsLimiter.new(resource, conditions[:author_member], { host_url: host_url, api_version: api_version, token: options.token, network: network }).calculate if conditions[:author_member]
-          results << Limiters::AssigneeMemberConditionsLimiter.new(resource, conditions[:assignee_member], { host_url: host_url, api_version: api_version, token: options.token, network: network }).calculate if conditions[:assignee_member]
-          !results.uniq.include?(false)
+
+          results << Filters::DateConditionsFilter.new(resource, conditions[:date]).calculate if conditions[:date]
+          results << Filters::VotesConditionsFilter.new(resource, conditions[:upvotes]).calculate if conditions[:upvotes]
+          results << Filters::ForbiddenLabelsConditionsFilter.new(resource, conditions[:forbidden_labels]).calculate if conditions[:forbidden_labels]
+          results << Filters::NoAdditionalLabelsConditionsFilter.new(resource, conditions.fetch(:labels) { [] }).calculate if conditions[:no_additional_labels]
+          results << Filters::AuthorMemberConditionsFilter.new(resource, conditions[:author_member], net).calculate if conditions[:author_member]
+          results << Filters::AssigneeMemberConditionsFilter.new(resource, conditions[:assignee_member], net).calculate if conditions[:assignee_member]
+          results << Filters::RubyConditionsFilter.new(resource, conditions, net).calculate if conditions[:ruby]
+
+          results.all?
         end
       end
 
       def process_resources(resource_type, resources, rule)
+        if options.dry_run
+          puts "\nThe following comments would be posted for the rule **#{rule[:name]}**:\n\n"
+        end
+
         resources.each do |resource|
           comment = build_comment(rule_actions(rule), resource: resource)
 
           if options.dry_run
-            puts "\nThe following comment would be posted for the rule '#{rule[:name]}':\n\n"
-            puts ">>>\n#{comment}\n>>>"
-            break
+            puts "# #{resource[:web_url]}\n```\n#{comment}\n```\n"
+          else
+            network.post_api(options.token, build_post_url(resource_type, resource), comment)
           end
-
-          network.post_api(options.token, build_post_url(resource_type, resource), comment)
         end
       end
 
@@ -144,12 +155,12 @@ module Gitlab
         }
 
         condition_builders = []
-        condition_builders << FilterBuilders::MultiFilterBuilder.new('labels', conditions[:labels], ',') if conditions[:labels]
-        condition_builders << FilterBuilders::SingleFilterBuilder.new('state', conditions[:state]) if conditions[:state]
-        condition_builders << FilterBuilders::MultiFilterBuilder.new('milestone', conditions[:milestone], ',') if conditions[:milestone]
+        condition_builders << APIQueryBuilders::MultiQueryParamBuilder.new('labels', conditions[:labels], ',') if conditions[:labels]
+        condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new('state', conditions[:state]) if conditions[:state]
+        condition_builders << APIQueryBuilders::MultiQueryParamBuilder.new('milestone', conditions[:milestone], ',') if conditions[:milestone]
 
         condition_builders.each do |condition_builder|
-          params[condition_builder.filter_name] = condition_builder.filter_content
+          params[condition_builder.param_name] = condition_builder.param_content
         end
 
         get_url = UrlBuilders::UrlBuilder.new(

data/lib/gitlab/triage/expand_condition.rb

@@ -0,0 +1,21 @@
+require_relative 'expand_condition/sequence'
+
+module Gitlab
+  module Triage
+    module ExpandCondition
+      PIPELINE = [
+        Sequence
+      ].freeze
+
+      def self.perform(conditions, pipeline = PIPELINE, &block)
+        expand([conditions], pipeline).each(&block)
+      end
+
+      def self.expand(conditions, pipeline = PIPELINE)
+        pipeline.inject(conditions) do |result, job|
+          result.flat_map(&job.method(:expand))
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/expand_condition/sequence.rb

@@ -0,0 +1,19 @@
+require_relative 'sequence/expansion'
+
+module Gitlab
+  module Triage
+    module ExpandCondition
+      module Sequence
+        def self.expand(conditions)
+          labels = conditions[:labels]
+
+          return conditions unless labels
+
+          Expansion.perform(labels).map do |new_labels|
+            conditions.merge(labels: new_labels)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/expand_condition/sequence/expansion.rb

@@ -0,0 +1,187 @@
+module Gitlab
+  module Triage
+    module ExpandCondition
+      module Sequence
+        module Expansion
+          PATTERN = /\{(\d+)\.\.(\d+)\}/
+
+          # This method will take a list of strings, which contains the
+          # sequence pattern, and expand them into each possible matches.
+          # For example, suppose the input is:
+          #
+          # * a:{0..1}
+          # * b:{2..3}
+          # * c
+          #
+          # The result would be:
+          #
+          # * * a:0
+          #   * b:2
+          #   * c
+          # * * a:0
+          #   * b:3
+          #   * c
+          # * * a:1
+          #   * b:2
+          #   * c
+          # * * a:1
+          #   * b:3
+          #   * c
+          #
+          # We get this by picking the 1st number from the 1st string,
+          # which is 0 from "a:{0..1}", and the 1st number from the
+          # 2nd string, which is 2 from "b:{2..3}", and since the 3rd
+          # string is just a fixed string, we just pick it.
+          #
+          # This way we have the first possible match, that is:
+          #
+          # * a:0
+          # * b:2
+          # * c
+          #
+          # Then we repeat the process by picking the next number for the
+          # next possible match, starting from the least significant
+          # string, which is c, but there's nothing more to pick. Then we
+          # go to the next one, which will be the 2nd string: "b:{2..3}",
+          # and we pick the 2nd number for it: 3. Since we have a new pick,
+          # we have a new possible match:
+          #
+          # * a:0
+          # * b:3
+          # * c
+          #
+          # Again we repeat the process, and 2nd string doesn't have more
+          # choices therefore we need to go to the 1st string now. When
+          # this happens, we'll need to reset the picks from the previous
+          # string, thus 2nd string will go back to 2. The next number for
+          # the 1st string is 1, and then we form the new match:
+          #
+          # * a:1
+          # * b:2
+          # * c
+          #
+          # The next step will be the last match by picking the next number
+          # from the 2nd string again: 3, and we get:
+          #
+          # * a:1
+          # * b:3
+          # * c
+          #
+          # The method will stop here because it had walked through all the
+          # possible combinations. The total number of results is the product
+          # of numbers of sequences.
+          #
+          # Note that a string can contain multiple sequences, and it will
+          # also walk through them one by one. For example, given:
+          #
+          # * a:{0..1}:{2..3}
+          # * c
+          #
+          # We'll get:
+          #
+          # * * a:0:2
+          #   * c
+          # * * a:0:3
+          #   * c
+          # * * a:1:2
+          #   * c
+          # * * a:1:3
+          #   * c
+          def self.perform(strings)
+            expanded_strings = strings.map(&method(:expand_sequences))
+
+            product_of_all(expanded_strings)
+          end
+
+          # This method returns the product of list of lists. For example,
+          # giving it [%w[a:0 a:1], %w[b:2 b:3], %w[c]] will return:
+          #
+          # [%w[a:0 b:2 c], %w[a:0 b:3 c], %w[a:1 b:2 c], %w[a:1 b:3 c]]
+          def self.product_of_all(expanded_strings)
+            expanded_strings.first.product(*expanded_strings.drop(1))
+          end
+
+          # This method expands the string from the sequences. For example,
+          # giving it "a:{0..1}:{2..3}" will return:
+          #
+          # %w[
+          #   a:0:2
+          #   a:0:3
+          #   a:1:2
+          #   a:1:3
+          # ]
+          def self.expand_sequences(string)
+            expand(string, scan_sequences(string))
+          end
+
+          # This method extracts the sequences from the string. For example,
+          # giving it "a:{0..1}:{2..3}" will return:
+          #
+          # [0..1, 2..3]
+          def self.scan_sequences(string)
+            string.scan(PATTERN).map do |(lower, upper)|
+              Integer(lower)..Integer(upper)
+            end
+          end
+
+          # This recursive method does the heavy lifting. It substitutes the
+          # sequence patterns in a string with a picked number from the
+          # sequence, and collect all the results. Here's an example:
+          #
+          # expand("a:{0..1}:{2..3}", [0..1, 2..3])
+          #
+          # This means that we want to pick the numbers from the sequences,
+          # and fill them back to the string containing the pattern in the
+          # respective order. We don't care which pattern it is because
+          # the order should have spoken for it. The result will be:
+          #
+          # %w[
+          #   a:0:2
+          #   a:0:3
+          #   a:1:2
+          #   a:1:3
+          # ]
+          #
+          # We start by picking the first sequence, which is 0..1 here. We
+          # want all the possible picks, thus we flat_map on it, substituting
+          # the first pattern with the picked number. This means we get:
+          #
+          # "a:0:{2..3}"
+          #
+          # For the first iteration. Before we jump to the next pick from the
+          # sequence, we recursively do this again on the current string,
+          # which only has one sequence pattern left. It will be called like:
+          #
+          # expand("a:0:{2..3}", [2..3])
+          #
+          # Because we also dropped the first sequence we have already used.
+          # On the next recursive call, we don't have any sequences left,
+          # therefore we just return the current string: "a:0:2".
+          #
+          # Flattening the recursion, it might look like this:
+          #
+          # (0..1).flat_map do |x|
+          #   (2..3).flat_map do |y|
+          #     "a:{0..1}:{2..3}".sub(PATTERN, x.to_s).sub(PATTERN, y.to_s)
+          #   end
+          # end
+          #
+          # So here we could clearly see that we go deep first, substituting
+          # the least significant pattern first, and then go back to the
+          # previous one, until there's nothing more to pick.
+          def self.expand(string, sequences)
+            if sequences.empty?
+              [string]
+            else
+              remainings = sequences.drop(1)
+
+              sequences.first.flat_map do |number|
+                expand(string.sub(PATTERN, number.to_s), remainings)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filters/assignee_member_conditions_filter.rb

@@ -0,0 +1,13 @@
+require_relative 'member_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class AssigneeMemberConditionsFilter < MemberConditionsFilter
+        def member_field
+          :assignee
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/filters/author_member_conditions_filter.rb

@@ -0,0 +1,13 @@
+require_relative 'member_conditions_filter'
+
+module Gitlab
+  module Triage
+    module Filters
+      class AuthorMemberConditionsFilter < MemberConditionsFilter
+        def member_field
+          :author
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/{limiters/base_conditions_limiter.rb → filters/base_conditions_filter.rb}

@@ -2,61 +2,73 @@ require 'active_support/all'
 
 module Gitlab
   module Triage
-    module Limiters
-      class BaseConditionsLimiter
+    module Filters
+      class BaseConditionsFilter
         def initialize(resource, condition)
           @resource = resource
           validate_condition(condition)
           initialize_variables(condition)
         end
 
-        def self.params_limiter_names(params = nil)
-          params ||= limiter_parameters
+        def calculate
+          raise NotImplementedError
+        end
+
+        def self.filter_parameters
+          []
+        end
+
+        def self.params_filter_names(params = nil)
+          params ||= filter_parameters
 
           params.map do |param|
             param[:name]
           end
         end
 
-        def self.all_params_limiter_names
-          params_limiter_names
+        def self.all_params_filter_names
+          params_filter_names
         end
 
         def self.params_checking_condition_value
-          params_limiter_names params_check_for_field(:values)
+          params_filter_names params_check_for_field(:values)
         end
 
         def self.params_checking_condition_type
-          params_limiter_names params_check_for_field(:type)
+          params_filter_names params_check_for_field(:type)
         end
 
         def self.params_check_for_field(field)
-          limiter_parameters.select do |param|
+          filter_parameters.select do |param|
             param[field].present?
           end
         end
 
+        private
+
         def validate_condition(condition)
           validate_required_parameters(condition)
           validate_parameter_types(condition)
           validate_parameter_content(condition)
         end
 
+        def initialize_variables(condition); end
+
         def validate_required_parameters(condition)
-          self.class.limiter_parameters.each do |param|
+          self.class.filter_parameters.each do |param|
             raise ArgumentError, "#{param[:name]} is a required parameter" unless condition[param[:name]]
           end
         end
 
         def validate_parameter_types(condition)
-          self.class.limiter_parameters.each do |param|
+          self.class.filter_parameters.each do |param|
             param_types = Array(param[:type]).flatten
             raise ArgumentError, "#{param[:name]} must be of type #{param[:type]}" unless param_types.any? { |type| condition[param[:name]].is_a?(type) }
           end
         end
 
         def validate_parameter_content(condition)
-          self.class.limiter_parameters.each do |param|
+          self.class.filter_parameters.each do |param|
             if param[:values]
               raise ArgumentError, "#{param[:name]} must be of one of #{param[:values].join(',')}" unless param[:values].include?(condition[param[:name]])
             end

data/lib/gitlab/triage/{limiters/date_conditions_limiter.rb → filters/date_conditions_filter.rb}

@@ -1,14 +1,14 @@
-require_relative 'base_conditions_limiter'
+require_relative 'base_conditions_filter'
 
 module Gitlab
   module Triage
-    module Limiters
-      class DateConditionsLimiter < BaseConditionsLimiter
+    module Filters
+      class DateConditionsFilter < BaseConditionsFilter
         ATTRIBUTES = %w[updated_at created_at].freeze
         CONDITIONS = %w[older_than newer_than].freeze
         INTERVAL_TYPES = %w[days weeks months years].freeze
 
-        def self.limiter_parameters
+        def self.filter_parameters
           [
             {
               name: :attribute,

data/lib/gitlab/triage/{limiters/forbidden_labels_conditions_limiter.rb → filters/forbidden_labels_conditions_filter.rb}

@@ -1,13 +1,9 @@
-require_relative 'base_conditions_limiter'
+require_relative 'base_conditions_filter'
 
 module Gitlab
   module Triage
-    module Limiters
-      class ForbiddenLabelsConditionsLimiter < BaseConditionsLimiter
-        def self.limiter_parameters
-          []
-        end
-
+    module Filters
+      class ForbiddenLabelsConditionsFilter < BaseConditionsFilter
         def validate_condition(condition)
           raise ArgumentError, 'condition must be an array containing forbidden label values' unless condition.is_a?(Array)
         end

data/lib/gitlab/triage/{limiters/member_conditions_limiter.rb → filters/member_conditions_filter.rb}

@@ -1,10 +1,10 @@
-require_relative 'base_conditions_limiter'
+require_relative 'base_conditions_filter'
 require_relative '../url_builders/url_builder'
 
 module Gitlab
   module Triage
-    module Limiters
-      class MemberConditionsLimiter < BaseConditionsLimiter
+    module Filters
+      class MemberConditionsFilter < BaseConditionsFilter
         SOURCES = %w[project group].freeze
         CONDITIONS = %w[member_of not_member_of].freeze
 
@@ -14,7 +14,7 @@ module Gitlab
           super(resource, condition)
         end
 
-        def self.limiter_parameters
+        def self.filter_parameters
           [
             {
               name: :source,
@@ -61,7 +61,7 @@ module Gitlab
         end
 
         def members
-          @members ||= @network.query_api(@net[:token], member_url)
+          @members ||= @network.query_api_cached(@net[:token], member_url)
         end
 
         def member_url

data/lib/gitlab/triage/{limiters/name_conditions_limiter.rb → filters/name_conditions_filter.rb}

@@ -1,13 +1,9 @@
-require_relative 'base_conditions_limiter'
+require_relative 'base_conditions_filter'
 
 module Gitlab
   module Triage
-    module Limiters
-      class NameConditionsLimiter < BaseConditionsLimiter
-        def self.limiter_parameters
-          []
-        end
-
+    module Filters
+      class NameConditionsFilter < BaseConditionsFilter
         def initialize_variables(matching_name)
           @attribute = :name
           @matching_name = matching_name

data/lib/gitlab/triage/{limiters/no_additional_labels_conditions_limiter.rb → filters/no_additional_labels_conditions_filter.rb}

@@ -1,10 +1,10 @@
-require_relative 'base_conditions_limiter'
+require_relative 'base_conditions_filter'
 
 module Gitlab
   module Triage
-    module Limiters
-      class NoAdditionalLabelsConditionsLimiter < BaseConditionsLimiter
-        def self.limiter_parameters
+    module Filters
+      class NoAdditionalLabelsConditionsFilter < BaseConditionsFilter
+        def self.filter_parameters
           []
         end
 

data/lib/gitlab/triage/filters/ruby_conditions_filter.rb

@@ -0,0 +1,31 @@
+require_relative 'base_conditions_filter'
+require_relative '../resource/context'
+require 'date'
+
+module Gitlab
+  module Triage
+    module Filters
+      class RubyConditionsFilter < BaseConditionsFilter
+        def self.limiter_parameters
+          [{ name: :ruby, type: String }]
+        end
+
+        def initialize(resource, condition, net = {})
+          super(resource, condition)
+
+          @net = net
+        end
+
+        def calculate
+          !!Resource::Context.new(@resource, @net).eval(@expression)
+        end
+
+        private
+
+        def initialize_variables(condition)
+          @expression = condition[:ruby]
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/{limiters/votes_conditions_limiter.rb → filters/votes_conditions_filter.rb}

@@ -1,13 +1,13 @@
-require_relative 'base_conditions_limiter'
+require_relative 'base_conditions_filter'
 
 module Gitlab
   module Triage
-    module Limiters
-      class VotesConditionsLimiter < BaseConditionsLimiter
+    module Filters
+      class VotesConditionsFilter < BaseConditionsFilter
         ATTRIBUTES = %w[upvotes downvotes].freeze
         CONDITIONS = %w[greater_than less_than].freeze
 
-        def self.limiter_parameters
+        def self.filter_parameters
           [
             {
               name: :attribute,

data/lib/gitlab/triage/network.rb

@@ -14,6 +14,11 @@ module Gitlab
       def initialize(adapter, options = {})
         @adapter = adapter
         @options = options
+        @cache = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      def query_api_cached(token, url)
+        @cache.dig(token, url) || @cache[token][url] = query_api(token, url)
       end
 
       def query_api(token, url)

data/lib/gitlab/triage/resource/base.rb

@@ -0,0 +1,46 @@
+require_relative '../url_builders/url_builder'
+
+module Gitlab
+  module Triage
+    module Resource
+      class Base
+        attr_reader :resource, :net
+
+        def initialize(new_resource, new_net)
+          @resource = new_resource
+          @net = new_net
+        end
+
+        private
+
+        def network
+          net[:network]
+        end
+
+        def url(params = {})
+          UrlBuilders::UrlBuilder.new(
+            net_opts.merge(params: { per_page: 100 }.merge(params))
+          ).build
+        end
+
+        def net_opts
+          {
+            host_url: net[:host_url],
+            api_version: net[:api_version],
+            resource_type: self.class.name.demodulize.underscore.pluralize,
+            source: source,
+            source_id: resource[:"#{source.singularize}_id"]
+          }
+        end
+
+        def source
+          if resource[:project_id]
+            'projects'
+          elsif resource[:group_id]
+            'groups'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/resource/context.rb

@@ -0,0 +1,34 @@
+require_relative 'base'
+require_relative 'milestone'
+
+module Gitlab
+  module Triage
+    module Resource
+      class Context < Base
+        EvaluationError = Class.new(RuntimeError)
+
+        def eval(ruby)
+          instance_eval <<~RUBY
+            begin
+              #{ruby}
+            rescue StandardError, ScriptError => e
+              raise EvaluationError.new(e.message)
+            end
+          RUBY
+        rescue EvaluationError => e
+          # This way we could obtain the original backtrace and error
+          # If we just let instance_eval raise an error, the backtrace
+          # won't contain the actual line where it's giving an error.
+          raise e.cause
+        end
+
+        private
+
+        def milestone
+          @milestone ||=
+            resource[:milestone] && Milestone.new(resource[:milestone], net)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/resource/milestone.rb

@@ -0,0 +1,82 @@
+require_relative 'base'
+require 'date'
+require 'time'
+
+module Gitlab
+  module Triage
+    module Resource
+      class Milestone < Base
+        FIELDS = %i[
+          id
+          iid
+          project_id
+          group_id
+          title
+          description
+          state
+        ].freeze
+
+        DATE_FIELDS = %i[
+          due_date
+          start_date
+        ].freeze
+
+        TIME_FIELDS = %i[
+          updated_at
+          created_at
+        ].freeze
+
+        FIELDS.each do |field|
+          define_method(field) do
+            resource[field]
+          end
+        end
+
+        DATE_FIELDS.each do |field|
+          define_method(field) do
+            value = resource[field]
+
+            Date.parse(value) if value
+          end
+        end
+
+        TIME_FIELDS.each do |field|
+          define_method(field) do
+            value = resource[field]
+
+            Time.parse(value) if value
+          end
+        end
+
+        def succ
+          index = current_index
+
+          all_active_with_start_date[index.succ] if index
+        end
+
+        def active?
+          state == 'active'
+        end
+
+        private
+
+        def current_index
+          all_active_with_start_date
+            .index { |milestone| milestone.id == id }
+        end
+
+        def all_active_with_start_date
+          @all_active_with_start_date ||=
+            all_active.select(&:start_date).sort_by(&:start_date)
+        end
+
+        def all_active
+          @all_active ||=
+            network
+              .query_api_cached(net[:token], url(state: 'active'))
+              .map { |milestone| self.class.new(milestone, net) }
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/version.rb

@@ -1,5 +1,5 @@
 module Gitlab
   module Triage
-    VERSION = '0.6.0'.freeze
+    VERSION = '0.7.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-triage
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - GitLab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-02 00:00:00.000000000 Z
+date: 2018-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
 description: 
 email:
 - remy@rymai.me
@@ -117,6 +131,9 @@ files:
 - bin/gitlab-triage
 - gitlab-triage.gemspec
 - lib/gitlab/triage.rb
+- lib/gitlab/triage/api_query_builders/base_query_param_builder.rb
+- lib/gitlab/triage/api_query_builders/multi_query_param_builder.rb
+- lib/gitlab/triage/api_query_builders/single_query_param_builder.rb
 - lib/gitlab/triage/command_builders/base_command_builder.rb
 - lib/gitlab/triage/command_builders/cc_command_builder.rb
 - lib/gitlab/triage/command_builders/comment_body_builder.rb
@@ -125,22 +142,26 @@ files:
 - lib/gitlab/triage/command_builders/remove_label_command_builder.rb
 - lib/gitlab/triage/command_builders/status_command_builder.rb
 - lib/gitlab/triage/engine.rb
-- lib/gitlab/triage/filter_builders/base_filter_builder.rb
-- lib/gitlab/triage/filter_builders/multi_filter_builder.rb
-- lib/gitlab/triage/filter_builders/single_filter_builder.rb
-- lib/gitlab/triage/limiters/assignee_member_conditions_limiter.rb
-- lib/gitlab/triage/limiters/author_member_conditions_limiter.rb
-- lib/gitlab/triage/limiters/base_conditions_limiter.rb
-- lib/gitlab/triage/limiters/date_conditions_limiter.rb
-- lib/gitlab/triage/limiters/forbidden_labels_conditions_limiter.rb
-- lib/gitlab/triage/limiters/member_conditions_limiter.rb
-- lib/gitlab/triage/limiters/name_conditions_limiter.rb
-- lib/gitlab/triage/limiters/no_additional_labels_conditions_limiter.rb
-- lib/gitlab/triage/limiters/votes_conditions_limiter.rb
+- lib/gitlab/triage/expand_condition.rb
+- lib/gitlab/triage/expand_condition/sequence.rb
+- lib/gitlab/triage/expand_condition/sequence/expansion.rb
+- lib/gitlab/triage/filters/assignee_member_conditions_filter.rb
+- lib/gitlab/triage/filters/author_member_conditions_filter.rb
+- lib/gitlab/triage/filters/base_conditions_filter.rb
+- lib/gitlab/triage/filters/date_conditions_filter.rb
+- lib/gitlab/triage/filters/forbidden_labels_conditions_filter.rb
+- lib/gitlab/triage/filters/member_conditions_filter.rb
+- lib/gitlab/triage/filters/name_conditions_filter.rb
+- lib/gitlab/triage/filters/no_additional_labels_conditions_filter.rb
+- lib/gitlab/triage/filters/ruby_conditions_filter.rb
+- lib/gitlab/triage/filters/votes_conditions_filter.rb
 - lib/gitlab/triage/network.rb
 - lib/gitlab/triage/network_adapters/base_adapter.rb
 - lib/gitlab/triage/network_adapters/httparty_adapter.rb
 - lib/gitlab/triage/network_adapters/test_adapter.rb
+- lib/gitlab/triage/resource/base.rb
+- lib/gitlab/triage/resource/context.rb
+- lib/gitlab/triage/resource/milestone.rb
 - lib/gitlab/triage/retryable.rb
 - lib/gitlab/triage/ui.rb
 - lib/gitlab/triage/url_builders/url_builder.rb

data/lib/gitlab/triage/filter_builders/base_filter_builder.rb

@@ -1,18 +0,0 @@
-module Gitlab
-  module Triage
-    module FilterBuilders
-      class BaseFilterBuilder
-        attr_reader :filter_name, :filter_contents
-
-        def initialize(filter_name, filter_contents)
-          @filter_name = filter_name
-          @filter_contents = filter_contents
-        end
-
-        def build_filter
-          "&#{filter_name}=#{filter_content}"
-        end
-      end
-    end
-  end
-end

data/lib/gitlab/triage/filter_builders/multi_filter_builder.rb

@@ -1,20 +0,0 @@
-require_relative 'base_filter_builder'
-
-module Gitlab
-  module Triage
-    module FilterBuilders
-      class MultiFilterBuilder < BaseFilterBuilder
-        attr_reader :separator
-
-        def initialize(filter_name, filter_contents, separator)
-          @separator = separator
-          super(filter_name, filter_contents)
-        end
-
-        def filter_content
-          filter_contents.join(separator)
-        end
-      end
-    end
-  end
-end

data/lib/gitlab/triage/filter_builders/single_filter_builder.rb

@@ -1,13 +0,0 @@
-require_relative 'base_filter_builder'
-
-module Gitlab
-  module Triage
-    module FilterBuilders
-      class SingleFilterBuilder < BaseFilterBuilder
-        def filter_content
-          filter_contents
-        end
-      end
-    end
-  end
-end

data/lib/gitlab/triage/limiters/assignee_member_conditions_limiter.rb

@@ -1,13 +0,0 @@
-require_relative 'member_conditions_limiter'
-
-module Gitlab
-  module Triage
-    module Limiters
-      class AssigneeMemberConditionsLimiter < MemberConditionsLimiter
-        def member_field
-          :assignee
-        end
-      end
-    end
-  end
-end

data/lib/gitlab/triage/limiters/author_member_conditions_limiter.rb

@@ -1,13 +0,0 @@
-require_relative 'member_conditions_limiter'
-
-module Gitlab
-  module Triage
-    module Limiters
-      class AuthorMemberConditionsLimiter < MemberConditionsLimiter
-        def member_field
-          :author
-        end
-      end
-    end
-  end
-end