forest_admin_datasource_toolkit 1.0.0.pre.beta.21

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7ed1e878cea7868c7a6443190c5dd53b880e154dcc5b4088532a156151464263
+  data.tar.gz: 41f2bf182d1851db0afb7a53a943d023b4698fa33fbfd584bee4ca7e40b702ac
+SHA512:
+  metadata.gz: a8376956ef1d90ae0f54d40aeb5ef81eef793d3aa16e7cd1da293cf927c1155ff7e7f8f848843175f21de6eabce34b11f934335665d29f99003e1d9b002835b6
+  data.tar.gz: 3b89ff9d179863b54a8000b3089acf05dbf6faff27d89fb6692b32107db752ad6ae9778ea34caebcdc133d6cba90e305cb295950666d6fc01f1609c6817658fc

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/README.md

@@ -0,0 +1,31 @@
+# ForestAdminDatasourceToolkit
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/forest_admin_datasource_toolkit`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/forest_admin_datasource_toolkit.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/forest_admin_datasource_toolkit.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+
+require_relative "lib/forest_admin_datasource_toolkit/version"
+
+Gem::Specification.new do |spec|
+  spec.name         = "forest_admin_datasource_toolkit"
+  spec.version      = ForestAdminDatasourceToolkit::VERSION
+  spec.authors      = ["Matthieu", "Nicolas"]
+  spec.email        = ["matthv@gmail.com", "nicolasalexandre9@gmail.com"]
+  spec.homepage     = "https://www.forestadmin.com"
+  spec.summary      = "Ruby agent for Forest Admin."
+  spec.description  = "Forest is a modern admin interface that works on all major web frameworks. This gem makes Forest
+admin work on any Ruby application."
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ForestAdmin/agent-ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/ForestAdmin/agent-ruby/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "false"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", ">= 6.1"
+  spec.add_dependency "zeitwerk", "~> 2.3"
+end

data/lib/forest_admin_datasource_toolkit/collection.rb

@@ -0,0 +1,50 @@
+module ForestAdminDatasourceToolkit
+  class Collection < Components::Contracts::CollectionContract
+    attr_accessor :fields, :segments
+
+    attr_reader :actions,
+                :charts,
+                :datasource,
+                :name,
+                :schema,
+                :native_driver
+
+    attr_writer :searchable,
+                :countable
+
+    def initialize(datasource, name, native_driver: nil)
+      super()
+      @datasource = datasource
+      @name = name
+      @native_driver = native_driver
+      @fields = {}
+      @schema = {}
+      @fields = {}
+      @actions = {}
+      @segments = {}
+      @charts = {}
+      @searchable = false
+      @countable = true
+    end
+
+    def is_countable?
+      @countable
+    end
+
+    def is_searchable?
+      @searchable
+    end
+
+    def add_field(name, field)
+      raise Exceptions::ForestException, "Field #{name} already defined in collection" if @fields.key?(name)
+
+      @fields[name] = field
+    end
+
+    def add_fields(fields)
+      fields.each do |name, field|
+        add_field(name, field)
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/caller.rb

@@ -0,0 +1,31 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    class Caller
+      attr_reader :id, :email, :first_name, :last_name, :tags, :team, :rendering_id, :timezone, :permission_level, :role
+
+      def initialize(
+        id:,
+        email:,
+        first_name:,
+        last_name:,
+        team:,
+        rendering_id:,
+        tags:,
+        timezone:,
+        permission_level:,
+        role: nil
+      )
+        @id = id
+        @email = email
+        @first_name = first_name
+        @last_name = last_name
+        @team = team
+        @rendering_id = rendering_id
+        @tags = tags
+        @timezone = timezone
+        @permission_level = permission_level
+        @role = role
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb

@@ -0,0 +1,51 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Contracts
+      class CollectionContract
+        def datasource
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def schema
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def name
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def execute
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def form
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def create(caller, data)
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def list(caller, filter, projection)
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def update(caller, filter, data)
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def delete(caller, filter)
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def aggregate(caller, filter, aggregation, limit = nil)
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def render_chart
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/contracts/datasource_contract.rb

@@ -0,0 +1,27 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Contracts
+      class DatasourceContract
+        def collections
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def charts
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def collection(name)
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def add_collection(collection)
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+
+        def render_chart(caller, name)
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb

@@ -0,0 +1,23 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class Aggregation
+        include ForestAdminDatasourceToolkit::Exceptions
+        attr_reader :operation, :field, :groups
+
+        def initialize(operation:, field: nil, groups: [])
+          validate(operation)
+          @operation = operation
+          @field = field
+          @groups = groups
+        end
+
+        def validate(operation)
+          return if %w[Count Sum Avg Max Min].include? operation
+
+          raise ForestException, "Aggregate operation #{operation} not allowed"
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/condition_tree_equivalent.rb

@@ -0,0 +1,66 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      module ConditionTree
+        class ConditionTreeEquivalent
+          def self.get_equivalent_tree(leaf, operators, column_type, timezone)
+            operator = leaf.operator
+
+            get_replacer(operator, operators, column_type).call(leaf, timezone)
+          end
+
+          def self.equivalent_tree?(operator, filter_operators, column_type)
+            return true if filter_operators.include?(operator)
+
+            !get_replacer(operator, filter_operators, column_type).nil?
+          end
+
+          class << self
+            private
+
+            def alternatives
+              @alternatives ||= {}
+            end
+
+            def get_alternatives(operator)
+              @alternatives ||= {}
+              comparisons = Transforms::Comparisons.transforms[operator] || []
+              pattern = Transforms::Pattern.transforms[operator] || []
+              time = Transforms::Times.transforms[operator] || []
+
+              @alternatives[operator] ||= comparisons.concat(pattern).concat(time)
+
+              @alternatives[operator]
+            end
+
+            def get_replacer(operator, filter_operators, column_type, visited = [])
+              return ->(leaf, _timezone) { leaf } if filter_operators.include?(operator)
+
+              get_alternatives(operator)&.each do |alt|
+                replacer = alt[:replacer]
+                depends_on = alt[:depends_on]
+                valid = alt[:for_types].nil? || alt[:for_types].include?(column_type)
+
+                if valid && !visited.include?(alt)
+                  depends_replacers = depends_on.map do |replacement|
+                    get_replacer(replacement, filter_operators, column_type, visited + [alt])
+                  end
+
+                  if depends_replacers.all? { |r| !r.nil? }
+                    return lambda { |leaf, timezone|
+                      replacer.call(leaf).replace_leafs do |sub_leaf|
+                        depends_replacers[depends_on.index(sub_leaf.operator)].call(sub_leaf, timezone)
+                      end
+                    }
+                  end
+                end
+              end
+
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/condition_tree_factory.rb

@@ -0,0 +1,123 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      module ConditionTree
+        class ConditionTreeFactory
+          include Nodes
+          include ForestAdminDatasourceToolkit::Exceptions
+
+          def self.match_none
+            ConditionTreeBranch.new('Or', [])
+          end
+
+          def self.match_records(collection, records)
+            ids = records.map { |record| ForestAdminDatasourceToolkit::Utils::Record.primary_keys(collection, record) }
+
+            match_ids(collection, ids)
+          end
+
+          def self.match_ids(collection, ids)
+            primary_key_names = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(collection)
+
+            raise ForestException, 'Collection must have at least one primary key' if primary_key_names.empty?
+
+            primary_key_names.each do |name|
+              operators = collection.fields[name].filter_operators
+              unless operators.include?(Operators::EQUAL) || operators.include?(Operators::IN)
+                raise ForestException, "Field '#{name}' must support operators: ['Equal', 'In']"
+              end
+            end
+
+            match_fields(primary_key_names, ids)
+          end
+
+          def self.intersect(trees = nil)
+            result = group('And', trees)
+            is_empty_and = result.is_a?(ConditionTreeBranch) && result.aggregator == 'And' && result.conditions.empty?
+
+            is_empty_and ? nil : result
+          end
+
+          def self.union(trees)
+            group('Or', trees)
+          end
+
+          def self.from_plain_object(json)
+            return nil if json.nil?
+
+            if leaf?(json)
+              ConditionTreeLeaf.new(json[:field], json[:operator], json[:value])
+            elsif branch?(json)
+              branch = ConditionTreeBranch.new(
+                json[:aggregator],
+                json[:conditions].map { |sub_tree| from_plain_object(sub_tree) }
+              )
+
+              branch.conditions.length == 1 ? branch.conditions[0] : branch
+            else
+              raise ForestException, 'Failed to instantiate condition tree from json'
+            end
+          end
+
+          def self.group(aggregator, trees = nil)
+            return nil if trees.nil? || trees.empty?
+
+            conditions = trees
+                         .filter { |tree| !tree.nil? }
+                         .reduce([]) do |current_conditions, tree|
+              if tree.is_a?(ConditionTreeBranch) && tree.aggregator == aggregator
+                current_conditions + tree.conditions
+              else
+                current_conditions + [tree]
+              end
+            end
+
+            conditions.length == 1 ? conditions[0] : ConditionTreeBranch.new(aggregator, conditions)
+          end
+
+          def self.match_fields(fields, values)
+            return ConditionTreeFactory.match_none if values.empty?
+
+            if fields.length == 1
+              field_values = values.map { |tuple| tuple[0] }
+
+              return field_values.length > 1 ? ConditionTreeLeaf.new(fields[0], 'In', field_values) : ConditionTreeLeaf.new(fields[0], 'Equal', field_values[0])
+            end
+
+            first_field, *other_fields = fields
+            groups = {}
+
+            values.each do |first_value, *other_values|
+              if groups.key?(first_value)
+                groups[first_value].push(other_values)
+              else
+                groups[first_value] = [other_values]
+              end
+            end
+
+            ConditionTreeFactory.union(
+              groups.map do |first_value, sub_values|
+                ConditionTreeFactory.intersect([
+                                                 ConditionTreeFactory.match_fields([first_field], [[first_value]]),
+                                                 ConditionTreeFactory.match_fields(other_fields, sub_values)
+                                               ])
+              end
+            )
+          end
+
+          def self.leaf?(tree)
+            return false unless tree.is_a?(Hash)
+
+            tree.key?(:field) && tree.key?(:operator) && (tree[:operator] == 'Present' || tree.key?(:value))
+          end
+
+          def self.branch?(tree)
+            return false unless tree.is_a?(Hash)
+
+            tree.key?(:aggregator) && tree.key?(:conditions)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/nodes/condition_tree.rb

@@ -0,0 +1,70 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      module ConditionTree
+        module Nodes
+          class ConditionTree
+            include ForestAdminDatasourceToolkit::Exceptions
+
+            def inverse
+              raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+            end
+
+            def replace_leafs(&handler)
+              raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+            end
+
+            def match(record, collection, timezone)
+              raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+            end
+
+            def for_each_leaf(handler)
+              raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+            end
+
+            def every_leaf(&handler)
+              raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+            end
+
+            def some_leaf(&handler)
+              raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+            end
+
+            def projection
+              raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+            end
+
+            def apply(records, collection, timezone)
+              records.select { |record| match(record, collection, timezone) }
+            end
+
+            def nest(prefix)
+              if prefix.empty?
+                self
+              else
+                replace_leafs { |leaf| leaf.override(field: "#{prefix}:#{leaf.field}") }
+              end
+            end
+
+            def unnest
+              prefix = nil
+              some_leaf do |leaf|
+                prefix = leaf.field.split(':').first
+                false
+              end
+              unless every_leaf { |leaf| leaf.field.start_with?(prefix) }
+                raise ForestException, 'Cannot unnest condition tree.'
+              end
+
+              replace_leafs { |leaf| leaf.override(field: leaf.field[prefix.length + 1..]) }
+            end
+
+            def replace_fields
+              replace_leafs { |leaf| leaf.override(field: yield(leaf.field)) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/nodes/condition_tree_branch.rb

@@ -0,0 +1,68 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      module ConditionTree
+        module Nodes
+          class ConditionTreeBranch < ConditionTree
+            attr_reader :aggregator, :conditions
+
+            def initialize(aggregator, conditions)
+              @aggregator = aggregator
+              @conditions = conditions
+              super()
+            end
+
+            def to_h
+              {
+                aggregator: @aggregator,
+                conditions: @conditions.map(&:to_h)
+              }
+            end
+
+            def inverse
+              aggregator = @aggregator == 'Or' ? 'And' : 'Or'
+              ConditionTreeBranch.new(
+                aggregator,
+                @conditions.map(&:inverse)
+              )
+            end
+
+            def replace_leafs(&handler)
+              ConditionTreeBranch.new(
+                @aggregator,
+                @conditions.map { |condition| condition.replace_leafs(&handler) }
+              )
+            end
+
+            def match(record, collection, timezone)
+              if @aggregator == 'And'
+                every_leaf { |condition| condition.match(record, collection, timezone) }
+              else
+                some_leaf { |condition| condition.match(record, collection, timezone) }
+              end
+            end
+
+            def for_each_leaf(&handler)
+              @conditions.each { |condition| condition.for_each_leaf(&handler) }
+              self
+            end
+
+            def every_leaf(&handler)
+              @conditions.all? { |condition| condition.every_leaf(&handler) }
+            end
+
+            def some_leaf(&handler)
+              @conditions.any? { |condition| condition.some_leaf(&handler) }
+            end
+
+            def projection
+              @conditions.reduce(Projection.new) do |memo, condition|
+                memo.union(condition.projection)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end