selector 0.0.1

data/config/metrics/cane.yml

@@ -0,0 +1,5 @@
+---
+abc_max: "10"
+line_length: "80"
+no_doc: "y"
+no_readme: "y"

data/config/metrics/churn.yml

@@ -0,0 +1,6 @@
+---
+ignore_files:
+- spec
+- config
+minimum_churn_count: 0
+start_date: "1 year ago"

data/config/metrics/flay.yml

@@ -0,0 +1,2 @@
+---
+minimum_score: 5

data/config/metrics/metric_fu.yml

@@ -0,0 +1,14 @@
+---
+folders: # The list of folders to be used by any metric.
+- lib
+metrics: # The list of allowed metrics. The other metrics are disabled.
+- cane
+- churn
+- flay
+- flog
+- reek
+- roodi
+- saikuro
+format: html
+output: tmp/metric_fu
+verbose: false

data/config/metrics/reek.yml

@@ -0,0 +1 @@
+---

data/config/metrics/roodi.yml

@@ -0,0 +1,24 @@
+---
+AssignmentInConditionalCheck:
+CaseMissingElseCheck:
+ClassLineCountCheck:
+  line_count: 100
+ClassNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ClassVariableCheck:
+CyclomaticComplexityBlockCheck:
+  complexity: 2
+CyclomaticComplexityMethodCheck:
+  complexity: 3
+EmptyRescueBodyCheck:
+ForLoopCheck:
+MethodLineCountCheck:
+  line_count: 6
+MethodNameCheck:
+  pattern: !ruby/regexp /^[\||\^|\&|\!]$|^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+ModuleLineCountCheck:
+  line_count: 100
+ModuleNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ParameterNumberCheck:
+  parameter_count: 4

data/config/metrics/rubocop.yml

@@ -0,0 +1,72 @@
+---
+# settings added by the 'hexx-suit' module
+# output: "tmp/rubocop"
+# format: "html"
+
+AllCops:
+  Exclude:
+    - '**/db/schema.rb'
+
+Lint/HandleExceptions:
+  Exclude:
+    - '**/*_spec.rb'
+
+Lint/RescueException:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/AccessorMethodName:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/EmptyLinesAroundMethodBody:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Style/EmptyLineBetweenDefs:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Style/SingleLineMethods:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+Style/SpecialGlobalVars:
+  Exclude:
+    - '**/Gemfile'
+    - '**/*.gemspec'
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrivialAccessors:
+  Exclude:
+    - '**/*_spec.rb'

data/config/metrics/saikuro.yml

@@ -0,0 +1,3 @@
+---
+warn_cyclo:  4
+error_cyclo: 6

data/config/metrics/simplecov.yml

@@ -0,0 +1,6 @@
+---
+output: tmp/coverage
+filters: # The list of paths to be excluded from coverage checkup
+- "spec/"
+- "config/"
+groups: []

data/config/metrics/yardstick.yml

@@ -0,0 +1,37 @@
+---
+# Settings added by the 'hexx-suit' gem
+output: "tmp/yardstick/output.log"
+path: "lib/**/*.rb"
+rules:
+  ApiTag::Presence:
+    enabled: true
+    exclude: []
+  ApiTag::Inclusion:
+    enabled: true
+    exclude: []
+  ApiTag::ProtectedMethod:
+    enabled: true
+    exclude: []
+  ApiTag::PrivateMethod:
+    enabled: false
+    exclude: []
+  ExampleTag:
+    enabled: true
+    exclude: []
+  ReturnTag:
+    enabled: true
+    exclude: []
+  Summary::Presence:
+    enabled: true
+    exclude: []
+  Summary::Length:
+    enabled: true
+    exclude: []
+  Summary::Delimiter:
+    enabled: true
+    exclude: []
+  Summary::SingleLine:
+    enabled: true
+    exclude: []
+threshold: 100
+verbose: false

data/lib/selector.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require "ice_nine"
+require "singleton"
+
+require_relative "selector/condition"
+require_relative "selector/anything"
+require_relative "selector/nothing"
+
+require_relative "selector/not"
+require_relative "selector/and"
+require_relative "selector/or"
+
+require_relative "selector/collection"
+require_relative "selector/array"
+require_relative "selector/regexp"
+require_relative "selector/function"
+
+# Composable filters for lists of values
+#
+module Selector
+
+  # Creates a condition from options
+  #
+  # @param [Hash] options
+  #
+  # @return [Selector::Condition]
+  #
+  def self.new(options)
+    white = options.fetch(:only)   { ANYTHING }
+    black = options.fetch(:except) { NOTHING  }
+    build(white) - build(black)
+  end
+
+  # Factory method that builds a condition instance depending on argument type
+  #
+  # @param [Object] clause
+  #
+  # @return [Selector::Condition]
+  #
+  def self.build(clause)
+    return clause                 if [ANYTHING, NOTHING].include? clause
+    return Regexp.new(clause)     if clause.instance_of? ::Regexp
+    return Array.new(clause)      if [::Array, Set].include? clause.class
+    return Collection.new(clause) if clause.is_a? Enumerable
+    return Function.new(clause)   if clause.respond_to? :call
+    Array.new [clause]
+  end
+
+  private # for yard
+
+  ANYTHING = Anything.instance
+  NOTHING  = Nothing.instance
+
+end # module Selector

data/lib/selector/and.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module Selector
+
+  # The composition of several conditions. Requires each of them to be satisfied
+  #
+  # @example (see #[])
+  #
+  class And < Condition
+
+    # @private
+    def self.new(*attributes)
+      attrs = attributes.uniq - [ANYTHING]
+
+      return ANYTHING    if attrs.empty?
+      return attrs.first if attrs.count.equal?(1)
+      return NOTHING     if attrs.include? NOTHING
+      return NOTHING     if (attrs & attrs.map(&:!)).any?
+
+      super(*attrs)
+    end
+
+    # Checks if value satisfies each of composed conditions
+    #
+    #   @example
+    #     left  = Selector.new only: /foo/
+    #     right = Selector.new only: /bar/
+    #     composition = Selector::And.new(left, right)
+    #
+    #     composition[:foo]    # => false
+    #     composition[:bar]    # => false
+    #     composition[:foobar] # => true
+    #
+    # @param (see Selector::Composition#[])
+    #
+    # @return (see Selector::Composition#[])
+    #
+    def [](value)
+      attributes.detect { |part| !part[value] } ? false : true
+    end
+
+    # Adds the other condition to the composition (avoids nesting)
+    #
+    # @param (see Selector::Composition#&)
+    #
+    # @return (see Selector::Composition#&)
+    #
+    def &(other)
+      And.new(*attributes, other)
+    end
+
+    # Adds inversion of the other condition to the composition (avoids nesting)
+    #
+    # @param (see Selector::Composition#-)
+    #
+    # @return (see Selector::Composition#-)
+    #
+    def -(other)
+      And.new(*attributes, !other)
+    end
+
+  end # class And
+
+end # module Selector

data/lib/selector/anything.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Selector
+
+  # The condition that accepts any value
+  #
+  # @example (see #[])
+  #
+  class Anything < Condition
+
+    include Singleton
+
+    # @!method [](value)
+    # Returns true
+    #
+    # @example
+    #   condition = Selector::Anything.instance # singleton
+    #   condition[:foo] # => true
+    #
+    # @param (see Selector::Condition#[])
+    #
+    # @return [true]
+    #
+    def [](_value)
+      true
+    end
+
+  end # class Anything
+
+end # module Selector

data/lib/selector/array.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Selector
+
+  # The condition checks if a value is included to the array
+  #
+  class Array < Collection
+
+    # @private
+    def initialize(array)
+      super Set.new(array)
+    end
+
+    # Creates an AND composition
+    #
+    # If other value is a array, then creates modified array to avoid nesting
+    #
+    # @param (see Selector::Composition#&)
+    #
+    # @return (see Selector::Composition#&)
+    #
+    def &(other)
+      return super unless other.instance_of? self.class
+      self.class.new attribute & other.attribute
+    end
+
+    # Creates an OR composition
+    #
+    # If other value is a array, then creates modified array to avoid nesting
+    #
+    # @param (see Selector::Composition#|)
+    #
+    # @return (see Selector::Composition#|)
+    #
+    def |(other)
+      return super unless other.instance_of? self.class
+      self.class.new attribute | other.attribute
+    end
+
+  end # class Array
+
+end # module Selector

data/lib/selector/collection.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Selector
+
+  # The condition checks if a value is included to the collection
+  #
+  # @example (see #[])
+  #
+  class Collection < Condition
+
+    # @!method initialize(collection)
+    # Initializes the condition with a collection of allowed values
+    #
+    # @param [Enumerable] collection
+    #
+    def initialize(_)
+      super
+    end
+
+    # Checks if the array includes the value
+    #
+    # @example
+    #   condition = Set.new [:foo, :bar]
+    #   condition[:foo] # => true
+    #   condition[:baz] # => false
+    #
+    # @param (see Selector::Condition#[])
+    #
+    # @return (see Selector::Condition#[])
+    #
+    def [](value)
+      attribute.include? value
+    end
+
+  end # class Collection
+
+end # module Selector

data/lib/selector/condition.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+module Selector
+
+  # Describe an immutable condition for selecting values
+  #
+  class Condition
+
+    include Comparable
+
+    # @!attribute [r] attributes
+    #
+    # @return [Array] The array of initialized attributes
+    #
+    attr_reader :attributes
+
+    # The first attribute
+    #
+    # @return [Object]
+    #
+    def attribute
+      attributes.first
+    end
+
+    # @private
+    def initialize(*attributes)
+      @attributes = attributes
+      IceNine.deep_freeze(self)
+    end
+
+    # Compares the condition to the other object by type and attributes
+    #
+    # @param [Object] other
+    #
+    # @return [Boolean]
+    #
+    def ==(other)
+      other.instance_of?(self.class) && attributes.eql?(other.attributes)
+    end
+
+    # @!method [](value)
+    # Checks if the value satisfies the condtion
+    #
+    # @param [Object] value
+    #
+    # @return [Boolean]
+    #
+    # @abstract
+    # @raise [NotImplementedError] by default
+    #
+    def [](_value)
+      fail NotImplementedError.new "#{self.class}#[] not implemented"
+    end
+
+    # Inverts the condition
+    #
+    # @return [Selector::Condition]
+    #
+    def !
+      Not.new(self)
+    end
+
+    # Composes (by AND) the condition to the other condition
+    #
+    # @param [Selector::Condition] other
+    #
+    # @return [Selector::Condition]
+    #
+    def &(other)
+      And.new(self, other)
+    end
+
+    # Composes (by AND) the condition to inversion of the other condition
+    #
+    # This is the same as `&(!other)`
+    #
+    # @param [Selector::Condition] other
+    #
+    # @return [Selector::Condition]
+    #
+    def -(other)
+      And.new(self, !other)
+    end
+
+    # Composes (by OR) the condition to the other condition
+    #
+    # This is the same as `!((!self)&(!other))`
+    #
+    # @param [Selector::Condition] other
+    #
+    # @return [Selector::Condition]
+    #
+    def |(other)
+      Or.new(self, other)
+    end
+
+  end # class Condition
+
+end # module Selector