Class: Quo::Composing::ClassStrategy

Inherits:
BaseStrategy show all
Defined in:
lib/quo/composing/class_strategy.rb,
sig/generated/quo/composing/class_strategy.rbs

Overview

Base class for class composition strategies

Direct Known Subclasses

QueryClassesStrategy

Instance Method Summary collapse

Methods inherited from BaseStrategy

#applicable?, #compose

Instance Method Details

#assign_query_metadata(klass, left_query_class, right_query_class, joins, left_spec, right_spec) ⇒ void

This method returns an undefined value.

Parameters:



71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/quo/composing/class_strategy.rb', line 71

def assign_query_metadata(klass, left_query_class, right_query_class, joins, left_spec, right_spec)
  # merge spec and joins
  left_joins = left_spec ? left_spec[:joins] : []
  left_joins = left_joins.is_a?(Array) ? left_joins : [left_joins]
  joins = joins.is_a?(Array) ? joins : [joins] if joins
  merge_left_joins = joins ? joins + left_joins : left_joins

  klass.instance_variable_set(:@_composing_joins, merge_left_joins)
  klass.instance_variable_set(:@_left_specification, left_spec)
  klass.instance_variable_set(:@_right_specification, right_spec)
  klass.instance_variable_set(:@_left_query, left_query_class)
  klass.instance_variable_set(:@_right_query, right_query_class)
end

#collect_properties(chosen_superclass, left_query_class, right_query_class) ⇒ Hash[Symbol, Literal::Property]

Collect properties that need to be (re)defined on the composed class. Properties already declared on chosen_superclass are inherited via the normal Ruby/Literal class hierarchy and do not need to be re-registered; skipping them avoids the per-prop Literal::Property allocation, schema dup, and module_eval of reader/writer source on every Class.new.

Parameters:

  • chosen_superclass (Class)
  • left_query_class (Class)
  • right_query_class (Class)

Returns:

  • (Hash[Symbol, Literal::Property]) 


29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/quo/composing/class_strategy.rb', line 29

def collect_properties(chosen_superclass, left_query_class, right_query_class)
  existing = chosen_superclass.literal_properties.properties_index
  props = {}
  if left_query_class < Quo::Query
    left_query_class.literal_properties.properties_index.each do |name, property|
      props[name] = property unless existing.key?(name)
    end
  end
  if right_query_class < Quo::Query
    right_query_class.literal_properties.properties_index.each do |name, property|
      props[name] = property unless existing.key?(name)
    end
  end
  props
end

#create_composed_class(chosen_superclass, props) ⇒ Class & Quo::ComposedQuery

Parameters:

  • chosen_superclass (Class)
  • props (Hash[Symbol, Literal::Property])

Returns:



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/quo/composing/class_strategy.rb', line 48

def create_composed_class(chosen_superclass, props)
  Class.new(chosen_superclass) do
    include Quo::ComposedQuery
    props.each do |name, property|
      prop(
        name,
        property.type,
        property.kind,
        reader: property.reader,
        writer: property.writer,
        default: property.default
      )
    end
  end
end

#validate_query_classes(left_query_class, right_query_class) ⇒ void

This method returns an undefined value.

Parameters:

  • left_query_class (Class)
  • right_query_class (Class) 


14
15
16
17
18
 
# File 'lib/quo/composing/class_strategy.rb', line 14

def validate_query_classes(left_query_class, right_query_class)
  unless left_query_class.respond_to?(:<) && right_query_class.respond_to?(:<)
    raise ArgumentError, "Cannot compose #{left_query_class} and #{right_query_class}, are they both classes? If you want to use instances use `.merge_instances`"
  end
end