Module: Trax::Model::StructExtensions::ClassMethods

Defined in:
lib/trax/model/struct_extensions.rb

Instance Method Summary collapse

Instance Method Details

#define_model_scope_for(attribute_name, **options) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/trax/model/struct_extensions.rb', line 35

def define_model_scope_for(attribute_name, **options)
  attribute_klass = fields[attribute_name]

  case fields[attribute_name].type
  when :boolean
    define_where_scopes_for_boolean_property(attribute_name, attribute_klass, **options)
  when :enum
    define_scopes_for_enum(attribute_name, attribute_klass, **options)
  else
    define_where_scopes_for_property(attribute_name, attribute_klass, **options)
  end
end

#define_model_scopes_for(*attribute_names) ⇒ Object 



29
30
31
32
33
 
# File 'lib/trax/model/struct_extensions.rb', line 29

def define_model_scopes_for(*attribute_names)
  attribute_names.each do |attribute_name|
    define_model_scope_for(attribute_name)
  end
end

#define_scopes_for_enum(attribute_name, enum_klass, as: nil) ⇒ Object

this only supports properties 1 level deep, but works beautifully I.E. for this structure define_attributes do

struct :custom_fields do
  enum :color, :default => :blue do
    define :blue,     1
    define :red,      2
    define :green,    3
  end
end

end ::Product.by_custom_fields_color(:blue, :red) will return #color=blue, #color=red



61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/trax/model/struct_extensions.rb', line 61

def define_scopes_for_enum(attribute_name, enum_klass, as:nil)
  return unless has_active_record_ancestry?(enum_klass)

  model_class = model_class_for_property(enum_klass)
  field_name = enum_klass.parent_definition.name.demodulize.underscore
  attribute_name = enum_klass.name.demodulize.underscore
  scope_name = as || :"by_#{field_name}_#{attribute_name}"
  model_class.scope(scope_name, lambda{ |*_scope_values|
    _integer_values = enum_klass.select_values(*_scope_values.flat_compact_uniq!)
    _integer_values.map!(&:to_s)
    model_class.where("#{field_name} -> '#{attribute_name}' IN(?)", _integer_values)
  })
end

#define_where_scopes_for_boolean_property(attribute_name, property_klass, as: nil) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/trax/model/struct_extensions.rb', line 75

def define_where_scopes_for_boolean_property(attribute_name, property_klass, as:nil)
  return unless has_active_record_ancestry?(property_klass)

  model_class = model_class_for_property(property_klass)
  field_name = property_klass.parent_definition.name.demodulize.underscore
  attribute_name = property_klass.name.demodulize.underscore
  scope_name = as || :"by_#{field_name}_#{attribute_name}"
  model_class.scope(scope_name, lambda{ |*_scope_values|
    _scope_values.map!(&:to_s).flat_compact_uniq!
    model_class.where("#{field_name} -> '#{attribute_name}' IN(?)", _scope_values)
  })
end

#define_where_scopes_for_property(attribute_name, property_klass, as: nil) ⇒ Object 



88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/trax/model/struct_extensions.rb', line 88

def define_where_scopes_for_property(attribute_name, property_klass, as:nil)
  return unless has_active_record_ancestry?(property_klass)

  model_class = model_class_for_property(property_klass)
  field_name = property_klass.parent_definition.name.demodulize.underscore
  attribute_name = property_klass.name.demodulize.underscore
  scope_name = as || :"by_#{field_name}_#{attribute_name}"

  model_class.scope(scope_name, lambda{ |*_scope_values|
    _scope_values.map!(&:to_s).flat_compact_uniq!
    model_class.where("#{field_name} ->> '#{attribute_name}' IN(?)", _scope_values)
  })
end

#has_active_record_ancestry?(property_klass) ⇒ Boolean

Returns:

  • (Boolean) 


102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/trax/model/struct_extensions.rb', line 102

def has_active_record_ancestry?(property_klass)
  return false unless property_klass.respond_to?(:parent_definition)

  result = if property_klass.parent_definition.ancestors.include?(::ActiveRecord::Base)
    true
  else
    has_active_record_ancestry?(property_klass.parent_definition)
  end

  result
end

#model_class_for_property(property_klass) ⇒ Object 



114
115
116
117
118
119
120
121
122
 
# File 'lib/trax/model/struct_extensions.rb', line 114

def model_class_for_property(property_klass)
  result = if property_klass.parent_definition.ancestors.include?(::ActiveRecord::Base)
    property_klass.parent_definition
  else
    model_class_for_property(property_klass.parent_definition)
  end

  result
end

#permitted_keys ⇒ Object

bit of a hack for the sake of strong params for now



25
26
27
 
# File 'lib/trax/model/struct_extensions.rb', line 25

def permitted_keys
  @permitted_keys ||= properties.map(&:to_sym)
end