Class: MetabaseQuerySync::IR::Graph

Inherits:
Dry::Struct
  • Object
show all
Defined in:
lib/metabase_query_sync/ir/graph.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(attributes) ⇒ Graph

Returns a new instance of Graph.



16
17
18
19
 
# File 'lib/metabase_query_sync/ir/graph.rb', line 16

def initialize(attributes)
  super(attributes)
  assert_traversal
end

Class Method Details

.from_items(items) ⇒ Graph

create a struct from a heterogeneous collection of collection, pulse, or queries

Returns:



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/metabase_query_sync/ir/graph.rb', line 23

def self.from_items(items)
  new(items.reduce({collections: [], pulses: [], queries: []}) do |acc, item|
    case item
    when Collection
      acc[:collections] << item
    when Pulse
      acc[:pulses] << item
    when Query
      acc[:queries] << item
    else
      raise "Unexpected type provided from items (#{item.class}), expected instances of only Collection, Pulse, or Query"
    end
    acc
  end)
end

Instance Method Details

#collections ⇒ Array<Collection>

Returns:



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/metabase_query_sync/ir/graph.rb', line 11

class Graph < Dry::Struct
  attribute :collections, MetabaseQuerySync::Types::Strict::Array.of(Collection)
  attribute :pulses, MetabaseQuerySync::Types::Strict::Array.of(Pulse)
  attribute :queries, MetabaseQuerySync::Types::Strict::Array.of(Query)

  def initialize(attributes)
    super(attributes)
    assert_traversal
  end

  # create a struct from a heterogeneous collection of collection, pulse, or queries
  # @return [Graph]
  def self.from_items(items)
    new(items.reduce({collections: [], pulses: [], queries: []}) do |acc, item|
      case item
      when Collection
        acc[:collections] << item
      when Pulse
        acc[:pulses] << item
      when Query
        acc[:queries] << item
      else
        raise "Unexpected type provided from items (#{item.class}), expected instances of only Collection, Pulse, or Query"
      end
      acc
    end)
  end

  # @return [Array<Query>]
  def queries_by_pulse(pulse_id)
    queries.filter { |query| query.pulse == pulse_id }
  end

  private

  def assert_traversal
    pulse_ids = pulses.map(&:id).to_set
    queries.each do |q|
      raise "No pulse (#{q.pulse}) found for query (#{q.name})" unless pulse_ids === q.pulse
    end
  end

  # @param a [String]
  # @param b [String]
  def strcmp(a, b)
    a.downcase == b.downcase
  end
end

#pulses ⇒ Array<Pulse>

Returns:



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/metabase_query_sync/ir/graph.rb', line 11

class Graph < Dry::Struct
  attribute :collections, MetabaseQuerySync::Types::Strict::Array.of(Collection)
  attribute :pulses, MetabaseQuerySync::Types::Strict::Array.of(Pulse)
  attribute :queries, MetabaseQuerySync::Types::Strict::Array.of(Query)

  def initialize(attributes)
    super(attributes)
    assert_traversal
  end

  # create a struct from a heterogeneous collection of collection, pulse, or queries
  # @return [Graph]
  def self.from_items(items)
    new(items.reduce({collections: [], pulses: [], queries: []}) do |acc, item|
      case item
      when Collection
        acc[:collections] << item
      when Pulse
        acc[:pulses] << item
      when Query
        acc[:queries] << item
      else
        raise "Unexpected type provided from items (#{item.class}), expected instances of only Collection, Pulse, or Query"
      end
      acc
    end)
  end

  # @return [Array<Query>]
  def queries_by_pulse(pulse_id)
    queries.filter { |query| query.pulse == pulse_id }
  end

  private

  def assert_traversal
    pulse_ids = pulses.map(&:id).to_set
    queries.each do |q|
      raise "No pulse (#{q.pulse}) found for query (#{q.name})" unless pulse_ids === q.pulse
    end
  end

  # @param a [String]
  # @param b [String]
  def strcmp(a, b)
    a.downcase == b.downcase
  end
end

#queries ⇒ Array<Card>

Returns:

  • (Array<Card>) 


11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/metabase_query_sync/ir/graph.rb', line 11

class Graph < Dry::Struct
  attribute :collections, MetabaseQuerySync::Types::Strict::Array.of(Collection)
  attribute :pulses, MetabaseQuerySync::Types::Strict::Array.of(Pulse)
  attribute :queries, MetabaseQuerySync::Types::Strict::Array.of(Query)

  def initialize(attributes)
    super(attributes)
    assert_traversal
  end

  # create a struct from a heterogeneous collection of collection, pulse, or queries
  # @return [Graph]
  def self.from_items(items)
    new(items.reduce({collections: [], pulses: [], queries: []}) do |acc, item|
      case item
      when Collection
        acc[:collections] << item
      when Pulse
        acc[:pulses] << item
      when Query
        acc[:queries] << item
      else
        raise "Unexpected type provided from items (#{item.class}), expected instances of only Collection, Pulse, or Query"
      end
      acc
    end)
  end

  # @return [Array<Query>]
  def queries_by_pulse(pulse_id)
    queries.filter { |query| query.pulse == pulse_id }
  end

  private

  def assert_traversal
    pulse_ids = pulses.map(&:id).to_set
    queries.each do |q|
      raise "No pulse (#{q.pulse}) found for query (#{q.name})" unless pulse_ids === q.pulse
    end
  end

  # @param a [String]
  # @param b [String]
  def strcmp(a, b)
    a.downcase == b.downcase
  end
end

#queries_by_pulse(pulse_id) ⇒ Array<Query>

Returns:



40
41
42
 
# File 'lib/metabase_query_sync/ir/graph.rb', line 40

def queries_by_pulse(pulse_id)
  queries.filter { |query| query.pulse == pulse_id }
end