Module: Saddle::MethodTreeBuilder

Included in:
Client
Defined in:
lib/saddle/method_tree_builder.rb

Instance Method Summary collapse

Instance Method Details

#build_node_children(current_module, current_node, requester) ⇒ Object

Build out the traversal tree by module namespace



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/saddle/method_tree_builder.rb', line 63

def build_node_children(current_module, current_node, requester)
  return unless current_module
  current_module.constants.each do |const_symbol|
    const = current_module.const_get(const_symbol)

    if const.class == Module
      # A module means that it's a branch
      # Build the branch out with a base endpoint
      branch_node = current_node._build_and_attach_node(
        Saddle::TraversalEndpoint,
        const_symbol.to_s.underscore
      )
      # Build out the branch's endpoints on the new branch node
      self.build_node_children(const, branch_node, requester)
    end

    if const < Saddle::TraversalEndpoint
      # A class means that it's a node
      # Build out this endpoint on the current node
      current_node._build_and_attach_node(const)
    end
  end
end

#build_root_node(requester) ⇒ Object

Build our root node here. The root node is special in that it lives below the ‘endpoints’ directory, and so we need to manually check if it exists.



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/saddle/method_tree_builder.rb', line 38

def build_root_node(requester)
  if defined?(self.implementation_root)
    root_endpoint_file = File.join(
      self.implementation_root,
      'root_endpoint.rb'
    )
    if File.file?(root_endpoint_file)
      warn "[DEPRECATION] `root_endpoint.rb` is deprecated. Please use `ABSOLUTE_PATH` in your endpoints."
      # Load it and create our base endpoint
      require(root_endpoint_file)
      # RootEndpoint is the special class name for a root endpoint
      root_node_class = self.implementation_module::RootEndpoint
    else
      # 'root_endpoint.rb' doesn't exist, so create a dummy endpoint
      root_node_class = Saddle::RootEndpoint
    end
  else
    # we don't even have an implementation root, so create a dummy endpoint
    root_node_class = Saddle::RootEndpoint
  end
  root_node_class.new(requester, nil, self)
end

#build_tree(requester) ⇒ Object

Build out the endpoint structure from the root of the implementation



22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/saddle/method_tree_builder.rb', line 22

def build_tree(requester)
  root_node = build_root_node(requester)
  # Search out the implementations directory structure for endpoints
  if defined?(self.implementation_root)
    # For each endpoints directory, recurse down it to load the modules
    endpoints_directories.each do |endpoints_directories|
      Dir["#{endpoints_directories}/**/*.rb"].each { |f| require(f) }
    end
    build_node_children(self.endpoints_module, root_node, requester)
  end
  root_node
end

#endpoints_directories ⇒ Object

Get all directories under the implementation root named ‘endpoints’ This search allows for flexible structuring of gem



96
97
98
 
# File 'lib/saddle/method_tree_builder.rb', line 96

def endpoints_directories
  Dir["#{implementation_root}/**/"].select { |d| d.ends_with?('endpoints/') }
end

#endpoints_module ⇒ Object

Get the Endpoints module that lives within this implementation’s namespace



102
103
104
105
106
107
108
 
# File 'lib/saddle/method_tree_builder.rb', line 102

def endpoints_module
  begin
    implementation_module.const_get('Endpoints')
  rescue NameError
    nil # If there is no endpoints module, we just won't load any
  end
end

#implementation_module ⇒ Object

Get the module that the client implementation belongs to. This will act as the root namespace for endpoint traversal and construction



90
91
92
 
# File 'lib/saddle/method_tree_builder.rb', line 90

def implementation_module
  self.name.split('::')[0..-2].join('::').constantize
end