Class: SkinnyControllers::Lookup

Inherits:
Object
  • Object
show all
Includes:
EnsureExistence, Policy
Defined in:
lib/skinny_controllers/lookup.rb,
lib/skinny_controllers/lookup/model.rb,
lib/skinny_controllers/lookup/policy.rb,
lib/skinny_controllers/lookup/namespace.rb,
lib/skinny_controllers/lookup/operation.rb,
lib/skinny_controllers/lookup/ensure_existence.rb

Overview

This class provides a way to determine all names / classes of operations and policies based on he given information.

The class methods show what is required for each scenario

Defined Under Namespace

Modules: EnsureExistence, Model, Namespace, Operation, Policy

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Policy

class_from_model, class_name_from_model, define_policy_class, method_name_for_operation

Methods included from EnsureExistence

ensure_namespace!, ensure_operation_class!, ensure_policy_class!, use_defailt_operation

Constructor Details

#initialize(args = {}) ⇒ Lookup

  • @option [String] controller_class_name

  • @option [Class] controller_class

  • @option [String] verb

  • @option [String] operation_name

  • @option [String] model_name

  • @option [Class] model_class

  • @option [Hash] options

Parameters:

  • args (Hash) (defaults to: {}) —

    • all possible parameters



45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/skinny_controllers/lookup.rb', line 45

def initialize(args = {})
  @controller_class_name = args[:controller_class_name]
  @controller_class = args[:controller_class]
  @verb_for_action = args[:verb]
  @operation_name = args[:operation_name]
  @operation_class = args[:operation_class]
  @model_name = args[:model_name]
  @namespace = args[:namespace]
  @model_class = args[:model_class]
  @policy_method_name = args[:policy_method_name]
  @options = args[:options] || {}
end

Class Method Details

.from_controller(controller_class:, verb:, model_class:) ⇒ Object 



12
13
14
15
16
17
18
 
# File 'lib/skinny_controllers/lookup.rb', line 12

def from_controller(controller_class:, verb:, model_class:)
  Lookup.new(
    controller_class_name: controller_class.name,
    verb:                  verb,
    model_class:           model_class
  )
end

.from_operation(operation_class:, model_class:) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/skinny_controllers/lookup.rb', line 20

def from_operation(operation_class:, model_class:)
  qualified_name = operation_class.name
  parts = qualified_name.split('::')
  operation_name = parts[-2]
  operation_parts = operation_name.split(SkinnyControllers.operations_suffix)

  Lookup.new(
    verb:            parts.last,
    # namespace:       parts[0..-3],
    operation_name:  operation_name,
    operation_class: operation_class,
    model_class:     model_class,
    namespace:       qualified_name.deconstantize.deconstantize
  )
end

Instance Method Details

#controller_class_name ⇒ Object 



145
146
147
 
# File 'lib/skinny_controllers/lookup.rb', line 145

def controller_class_name
  @controller_class_name ||= @controller_class&.name
end

#model_class ⇒ Object 



85
86
87
 
# File 'lib/skinny_controllers/lookup.rb', line 85

def model_class
  @model_class ||= @options[:model_class] || model_name.safe_constantize
end

#model_name ⇒ Object 



89
90
91
 
# File 'lib/skinny_controllers/lookup.rb', line 89

def model_name
  @model_name ||= @model_class.try(:name) || resource_name
end

#namespace ⇒ String

Returns the namespace.

Returns:

  • (String) —

    the namespace



120
121
122
123
124
 
# File 'lib/skinny_controllers/lookup.rb', line 120

def namespace
  @namespace ||= begin
    resource_parts.length > 1 ? resource_parts[0..-2].join('::') : ''
  end
end

#namespace_lookup(qualified_name) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/skinny_controllers/lookup/ensure_existence.rb', line 45

def namespace_lookup(qualified_name)
  return if qualified_name.blank?
  klass = qualified_name.safe_constantize
  return klass if klass
  return unless qualified_name.include?('::')

  parts = qualified_name.split('::')

  # Api::V2::CategoriesNamespace
  # => Api::CategoriesNamespace
  demodulized = qualified_name.demodulize
  namespace = parts[0..-3]
  next_lookup = [namespace, demodulized].reject(&:blank?).join('::')
  result = namespace_lookup(next_lookup)
  return result if result

  # Api::V2::CategoriesNamespace
  # => V2::CategoriesNamespace
  next_lookup = parts[1..-1].join('::')
  namespace_lookup(next_lookup)
end

#namespaced_operation_name ⇒ String

Returns name of the supposed operation class.

Returns:

  • (String) —

    name of the supposed operation class



94
95
96
97
98
99
 
# File 'lib/skinny_controllers/lookup.rb', line 94

def namespaced_operation_name
  @namespaced_operation_name ||= [
    operation_namespace,
    @verb_for_action
  ].reject(&:blank?).join('::')
end

#namespaced_policy_name ⇒ Object 



101
102
103
104
105
106
 
# File 'lib/skinny_controllers/lookup.rb', line 101

def namespaced_policy_name
  @namespaced_policy_name ||= [
    namespace,
    "#{resource_name}#{SkinnyControllers.policy_suffix}"
  ].reject(&:blank?).join('::')
end

#operation_class ⇒ Object

PostsController

> PostOperations::Verb

Api::V2::PostsController

> Api::V2::PostOperations::Verb



63
64
65
66
67
68
69
70
71
72
 
# File 'lib/skinny_controllers/lookup.rb', line 63

def operation_class
  @operation_class ||= begin
    found_namespace = ensure_namespace!(operation_namespace)

    operation = namespaced_operation_name.split(found_namespace.name).last
    qualified_name = found_namespace ? found_namespace.name + operation : namespaced_operation_name

    ensure_operation_class!(qualified_name)
  end
end

#operation_lookup(qualified_name) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/skinny_controllers/lookup/ensure_existence.rb', line 89

def operation_lookup(qualified_name)
  return if qualified_name.blank?
  klass = qualified_name.safe_constantize

  # Return if the constant exists, or if we can't travel
  # up any higher.
  return klass if klass
  return unless qualified_name.scan(/::/).count > 1

  # "Api::V1::CategoryOperations::Create"
  # => "CategorOperations::Create"
  parts = qualified_name.split('::')
  target = parts[-2..-1]

  # TODO: Lookup Chopping of namespaces going ->
  # "Api::V1::CategoryOperations::Create"
  # => "V1::CategoryOperaitons::Create"

  # Lookup Chopping of namespaces going <-
  # "Api::V1::CategoryOperations::Create"
  # => "Api::CategoryOperations::Create"
  namespace = parts[0..-4]
  next_lookup = [namespace, target].reject(&:blank?).join('::')

  # recurse
  operation_lookup(next_lookup)
end

#operation_name ⇒ Object 



115
116
117
 
# File 'lib/skinny_controllers/lookup.rb', line 115

def operation_name
  @operation_name ||= "#{resource_name}#{SkinnyControllers.operations_suffix}"
end

#operation_namespace ⇒ Object 



108
109
110
111
112
113
 
# File 'lib/skinny_controllers/lookup.rb', line 108

def operation_namespace
  @operation_namespace ||= [
    namespace,
    operation_name
  ].reject(&:blank?).join('::')
end

#operation_parts ⇒ Object 



141
142
143
 
# File 'lib/skinny_controllers/lookup.rb', line 141

def operation_parts
  @operation_parts ||= operation_namespace&.split(/::|Operations/)
end

#policy_class ⇒ Object 



74
75
76
77
78
79
 
# File 'lib/skinny_controllers/lookup.rb', line 74

def policy_class
  @policy_class ||= begin
    ensure_namespace!(namespace) if namespace.present?
    ensure_policy_class!(namespaced_policy_name)
  end
end

#policy_lookup(qualified_name) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/skinny_controllers/lookup/ensure_existence.rb', line 67

def policy_lookup(qualified_name)
  return if qualified_name.blank?
  klass = qualified_name.safe_constantize

  # Return if the constant exists, or if we can't travel
  # up any higher.
  return klass if klass
  return unless qualified_name.include?('::')

  # "Api::V1::CategoryPolicy"
  # => "CategorPolicy"
  target = qualified_name.demodulize

  # "Api::V1::CategoryPolicy"
  # => "Api"
  namespace = qualified_name.deconstantize.deconstantize
  next_lookup = [namespace, target].reject(&:blank?).join('::')

  # recurse
  policy_lookup(next_lookup)
end

#policy_method_name ⇒ Object 



81
82
83
 
# File 'lib/skinny_controllers/lookup.rb', line 81

def policy_method_name
  @policy_method_name ||= @verb_for_action.underscore + POLICY_METHOD_SUFFIX
end

#resource_name ⇒ Object 



126
127
128
129
130
 
# File 'lib/skinny_controllers/lookup.rb', line 126

def resource_name
  @resource_name ||= resource_parts && resource_parts[-1].singularize ||
    @model_class&.name ||
    operation_parts && operation_parts[-1].singularize
end

#resource_parts ⇒ Object

PostsController

> Posts

Api::V2::PostsController

> Api, V2, Posts



137
138
139
 
# File 'lib/skinny_controllers/lookup.rb', line 137

def resource_parts
  @resource_parts ||= controller_class_name&.split(/::|Controller/)
end