Class: Innate::Action

Inherits:
Struct
  • Object
show all
Defined in:
lib/innate/action.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.create(hash = {}) ⇒ Action

Create a new Action instance. Note that the default cannot be a constant as assigning the value objects to the struct would modify them and might lead to bugs due to persisting action contents.

Parameters:

  • hash (Hash, #to_hash) (defaults to: {}) —

    used to seed new Action instance

Returns:

  • (Action) —

    action with the given defaults from hash

Author:

  • manveru



15
16
17
18
 
# File 'lib/innate/action.rb', line 15

def self.create(hash = {})
  default = {:options => {}, :variables => {}, :params => []}
  new(*default.merge(hash.to_hash).values_at(*ACTION_MEMBERS))
end

Instance Method Details

#binding ⇒ Binding

Returns binding of the instance for this Action.

Returns:

  • (Binding) —

    binding of the instance for this Action

See Also:

Author:

  • manveru



42
43
44
 
# File 'lib/innate/action.rb', line 42

def binding
  instance.binding
end

#call ⇒ String

Call the Action instance, will insert itself temporarily into Current.actions during the render operation so even in nested calls one can still access all other Action instances. Will initialize the assigned node and call Action#render

Returns:

  • (String) —

    The rendition of all nested calls

See Also:

Author:

  • manveru



34
35
36
 
# File 'lib/innate/action.rb', line 34

def call
  Current.actions ? wrap_in_current{ render } : render
end

#copy_variables(object = instance) ⇒ NilClass

Copy Action#variables as instance variables into the given object. Defaults to copying the variables to self.

Parameters:

  • object (Object #instance_variable_set) (defaults to: instance)

Returns:

  • (NilClass) —

    there is no indication of failure or success

See Also:

Author:

  • manveru



73
74
75
76
77
 
# File 'lib/innate/action.rb', line 73

def copy_variables(object = instance)
  self.variables.each do |iv, value|
    object.instance_variable_set("@#{iv}", value)
  end
end

#full_path ⇒ Object

Path to this action, including params, with the mapping of the current controller prepended.



132
133
134
 
# File 'lib/innate/action.rb', line 132

def full_path
  File.join(node.mapping, path)
end

#layout_view_or_method(name, arg) ⇒ Object 



114
115
116
 
# File 'lib/innate/action.rb', line 114

def layout_view_or_method(name, arg)
  [:layout, :view].include?(name) ? [arg, nil] : [nil, arg]
end

#merge!(hash) ⇒ Object 



20
21
22
23
 
# File 'lib/innate/action.rb', line 20

def merge!(hash)
  hash.each_pair{|key, value| send("#{key}=", value) }
  self
end

#name ⇒ Object

Try to figure out a sane name for current action.



126
127
128
 
# File 'lib/innate/action.rb', line 126

def name
  File.basename((method || view).to_s).split('.').first
end

#render ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/innate/action.rb', line 79

def render
  self.instance = instance = node.new
  self.variables[:content] ||= nil

  instance.wrap_action_call(self) do
    copy_variables
    self.method_value = instance.__send__(method, *params) if method
    self.view_value = View.read(view) if view

    body, content_type = wrap_in_layout{
      engine.call(self, view_value || method_value || '') }
    options[:content_type] ||= content_type if content_type
    body
  end
end

#render_in_layout ⇒ Object 



99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/innate/action.rb', line 99

def render_in_layout
  self.view, self.method = layout_view_or_method(*layout)
  self.options[:is_layout] = true
  self.params = []
  self.layout = self.view_value = nil
  self.sync_variables(self)

  body, content_type = yield

  self.sync_variables(self)
  self.variables[:content] = body

  return call, content_type
end

#sync_variables(from_action) ⇒ Action

Copy the instance variable names and values from given from_action#instance into the Action#variables of the action this method is called on.

Parameters:

  • from_action (Action #instance)

Returns:

See Also:

Author:

  • manveru



55
56
57
58
59
60
61
62
63
64
 
# File 'lib/innate/action.rb', line 55

def sync_variables(from_action)
  instance = from_action.instance

  instance.instance_variables.each{|variable|
    name = variable.to_s[1..-1].to_sym
    self.variables[name] = instance.instance_variable_get(variable)
  }

  from_action
end

#valid? ⇒ Boolean

Returns:

  • (Boolean) 


136
137
138
 
# File 'lib/innate/action.rb', line 136

def valid?
  node.needs_method? ? (method && view) : (method || view)
end

#wrap_in_current ⇒ Object 



118
119
120
121
122
123
 
# File 'lib/innate/action.rb', line 118

def wrap_in_current
  Current.actions << self
  yield
ensure
  Current.actions.delete(self)
end

#wrap_in_layout ⇒ Object 



95
96
97
 
# File 'lib/innate/action.rb', line 95

def wrap_in_layout
  layout ? dup.render_in_layout(&Proc.new) : yield
end