bbattribute_filters 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f5d2c3f9c55564f4b937904bc3ccb2a8b66f94a36bab34306f4fa9c0892b48c3
+  data.tar.gz: f45828c0965ab56e4dde4b6c8811609676e2a7827f66d2403d5eb1ec8ce5c81d
+SHA512:
+  metadata.gz: ca778e871b25c98b993d33bedd0541b6ee5db38636e3d9a1522dba6ad6c309418c1caf2e3c72a94f4d8da1793d50758a7e2bd891044681b885e31c338e6c74a3
+  data.tar.gz: 44ed0c2d7dd3973c30e728dd060f41353fb1885d8ba04934a196cbec6411b6db085d45a5988752d76115f29930b92af76e20e565c434a24100ae14c0fca4c2e8

data/lib/bbattribute_filters.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative 'bbattribute_filters/attribute'
+
+# The main BBAttributeFilters module. Should be included to
+module BBAttributeFilters
+  def self.included(base)
+    base.extend ClassMethods
+    base.class_eval do
+      # Gets all of the class Attributes. Please note this is the internal attributes
+      def filterable_attributes
+        self.class._get_fiterable_attributes
+      end
+
+      # @abstract Subclass is expected to implement #evaluate_attribute
+      # @!method evaluate_attribute(name)
+      #   Evaluate the value of the attribute using the symbol provided
+
+      # Gets all of the attributes as long as they pass the include? condition
+      # check
+      def all_attributes
+        filterable_attributes.each_with_object({}) do |(key, attr), to_return|
+          to_return[key] = attr.evaluate(self) if attr.include?(self)
+        end
+      end
+
+      # Gets a single attribute via the name, this will run the include? check on
+      # the attribute before evaulating it
+      # @param name {Symbol} The name of the attribute to retrieve
+      def attribute(name)
+        attr = filterable_attributes[name]
+        attr.evaluate(self) if attr&.include?(self)
+      end
+
+      # Gets a single attribute via the name but bypassed the included? check
+      # @param name {Symbol} The name of the attribute to retrieve
+      def attribute_forced(name)
+        attr = filterable_attributes[name]
+        attr ? attr.evaluate(self) : nil
+      end
+
+      # Gets a list of specific attributes based on the names give
+      def only_attributes(*only)
+        only.each_with_object({}) do |name, to_return|
+          to_return[name] = attribute(name)
+        end
+      end
+    end
+
+    # Rather than wasting time with an if check each time we access the attributes hash we instead
+    # set it up front upon include
+    base._set_fiterable_attributes({})
+  end
+
+  # The class methods on BBAttributeFilters
+  module ClassMethods
+    def inherited(base)
+      super
+      base._set_fiterable_attributes(@_filterable_attributes ? @_filterable_attributes.dup : {})
+    end
+
+    # Assigns a large set of attributes without options
+    def attributes(*attrs)
+      attrs.each do |attr|
+        attribute(attr)
+      end
+    end
+
+    # Assigns a single attribute
+    def attribute(name, options = {}, &block)
+      _add_filterable_attribute(options.fetch(:key, name),
+        BBAttributeFilters::Attribute.new(name, options, &block))
+    end
+
+    # Sets the serialized attributes variable
+    def _set_fiterable_attributes(attrs)
+      @_filterable_attributes = attrs
+    end
+
+    # Gets the serialized attributes variable
+    def _get_fiterable_attributes
+      @_filterable_attributes
+    end
+
+    # Adds a single serialized attribute. This is an internal method
+    # used by the attribute method
+    def _add_filterable_attribute(key, attr)
+      @_filterable_attributes[key] = attr
+    end
+  end
+end

data/lib/bbattribute_filters/attribute.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative('./builders/conditions')
+require_relative('./handlers/block')
+require_relative('./handlers/symbol')
+
+module BBAttributeFilters
+  # The attribute class. Wraps up a single instances of an attribute with the
+  # handler and condition
+  class Attribute
+    def initialize(name, options = {}, &block)
+      raise ArgumentError, 'BBAttributeFilters::Attribute - Name should be a symbol' unless name.is_a?(::Symbol)
+
+      @name = name
+      @handler = build_handler(name, &block)
+      @condition = build_condition(options)
+    end
+
+    def include?(serializer)
+      @condition.include?(serializer)
+    end
+
+    def exclude?(serializer)
+      @condition.exclude?(serializer)
+    end
+
+    def evaluate(serializer)
+      @handler.evaluate(serializer)
+    end
+
+    def condition_type
+      @condition.type
+    end
+
+    private
+
+    def build_condition(options)
+      Builders::Conditions.build_from_options(options)
+    end
+
+    def build_handler(name, &block)
+      if block_given?
+        BBAttributeFilters::Handlers::Block.new(&block)
+      else
+        BBAttributeFilters::Handlers::Evaluation.new(name)
+      end
+    end
+  end
+end

data/lib/bbattribute_filters/builders/conditions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative('../conditions/if')
+require_relative('../conditions/unless')
+require_relative('../conditions/none')
+
+module BBAttributeFilters
+  module Builders
+    # Builder for conditions
+    class Conditions
+      class << self
+        def build_from_options(options)
+          if options.key?(:if)
+            BBAttributeFilters::Conditions::If.new(options[:if])
+          elsif options.key?(:unless)
+            BBAttributeFilters::Conditions::Unless.new(options[:unless])
+          else
+            BBAttributeFilters::Conditions::None.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bbattribute_filters/conditions/condition.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative('../handlers/proc')
+require_relative('../handlers/symbol')
+
+module BBAttributeFilters
+  module Conditions
+    # The base class for all AttributeConditions. E.g. allows the :if :unless conditions to be
+    # used when creating attributes
+    class Condition
+
+      ALLOWED_CONDITIONS = %i[if unless none].freeze
+
+      attr_reader :type
+
+      def initialize(type, on)
+        unless invalid_type?(type)
+          raise ArgumentError, 'BBAttributeFilters::Conditions::Condition - Type should be :if, :unless or :none'
+        end
+
+        @type = type
+        @on = on
+        @handler = build_condition_handler(on)
+      end
+
+      def evaluate(evaluator)
+        @handler.evaluate(evaluator)
+      end
+
+      def include?(_serializer)
+        true
+      end
+
+      def exclude?(_serializer)
+        false
+      end
+
+      private
+
+      def invalid_type?(type)
+        Condition::ALLOWED_CONDITIONS.include?(type)
+      end
+
+      # Builds the handler which will process the given condition.
+      # Current options are Symbol, Proc
+      def build_condition_handler(on)
+        if on.is_a?(::Symbol)
+          Handlers::Symbol.new(on)
+        elsif on.is_a?(::Proc)
+          Handlers::Proc.new(on)
+        else
+          raise ArgumentError, 'BBAttributeFilters::Conditions::Condition - Condition should be a symbol or Proc'
+        end
+      end
+    end
+  end
+end

data/lib/bbattribute_filters/conditions/if.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative('condition')
+
+module BBAttributeFilters
+  module Conditions
+    ##
+    # Allows the handling of the :if condition
+    class If < Condition
+      def initialize(on)
+        super(:if, on)
+      end
+
+      def include?(serializer)
+        evaluate(serializer)
+      end
+
+      def exclude?(serializer)
+        !evaluate(serializer)
+      end
+    end
+  end
+end

data/lib/bbattribute_filters/conditions/none.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative('condition')
+
+module BBAttributeFilters
+  # The collections module
+  module Conditions
+    # Allows the handling of no condition
+    class None < Condition
+      def initialize
+        @type = :none
+        @on = nil
+      end
+    end
+
+    def evaluate(evaluator); end
+  end
+end

data/lib/bbattribute_filters/conditions/unless.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative('condition')
+
+module BBAttributeFilters
+  module Conditions
+    ##
+    # Allows the handling of the :unless condition
+    class Unless < Condition
+      def initialize(on)
+        super(:unless, on)
+      end
+
+      def include?(serializer)
+        !evaluate(serializer)
+      end
+
+      def exclude?(serializer)
+        evaluate(serializer)
+      end
+    end
+  end
+end

data/lib/bbattribute_filters/handlers/block.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BBAttributeFilters
+  module Handlers
+    # Handler which calls the block within the scope
+    # of the evaluator
+    class Block
+      def initialize(&block)
+        raise ArgumentError, 'BBAttributeFilters::Handlers::EvaluationHandler - Expected a Block' unless block_given?
+
+        @block = block
+      end
+
+      def evaluate(evaluator)
+        evaluator.instance_eval(&@block)
+      end
+    end
+  end
+end

data/lib/bbattribute_filters/handlers/evaluation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BBAttributeFilters
+  module Handlers
+    # Handler which passes the name of the attribute directly
+    # to the BBAttributeFilter via the evaluate_attribute
+    class Evaluation
+      def initialize(symbol)
+        unless symbol.is_a?(::Symbol)
+          raise ArgumentError, 'BBAttributeFilters::Handlers::EvaluationHandler - Expected a Symbol'
+        end
+
+        @symbol = symbol
+      end
+
+      def evaluate(evaluator)
+        evaluator.evaluate_attribute(@symbol)
+      end
+    end
+  end
+end

data/lib/bbattribute_filters/handlers/proc.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BBAttributeFilters
+  module Handlers
+    # Handler which calls the proc within the scope
+    # of the evaluator
+    class Proc
+      def initialize(proc)
+        unless proc.is_a?(::Proc)
+          raise ArgumentError, 'BBAttributeFilters::Handlers::EvaluationHandler - Expected a Proc'
+        end
+
+        @proc = proc
+      end
+
+      def evaluate(evaluator)
+        evaluator.instance_exec(&@proc)
+      end
+    end
+  end
+end

data/lib/bbattribute_filters/handlers/symbol.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BBAttributeFilters
+  module Handlers
+    # Handler which passes the symbol provided to the
+    # evaluator
+    class Symbol
+      def initialize(symbol)
+        unless symbol.is_a?(::Symbol)
+          raise ArgumentError, 'BBAttributeFilters::Handlers::EvaluationHandler - Expected a Symbol'
+        end
+
+        @symbol = symbol
+      end
+
+      def evaluate(evaluator)
+        evaluator.public_send(@symbol)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: bbattribute_filters
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Stuart Farnaby, Big Bear Studios
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.7.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.7.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.18.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.18.5
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bbattribute_filters.rb
+- lib/bbattribute_filters/attribute.rb
+- lib/bbattribute_filters/builders/conditions.rb
+- lib/bbattribute_filters/conditions/condition.rb
+- lib/bbattribute_filters/conditions/if.rb
+- lib/bbattribute_filters/conditions/none.rb
+- lib/bbattribute_filters/conditions/unless.rb
+- lib/bbattribute_filters/handlers/block.rb
+- lib/bbattribute_filters/handlers/evaluation.rb
+- lib/bbattribute_filters/handlers/proc.rb
+- lib/bbattribute_filters/handlers/symbol.rb
+homepage: https://gitlab.com/big-bear-studios-open-source/bbattributefilters
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key:
+specification_version: 4
+summary: ''
+test_files: []