Class: Wedge::Component

Inherits:
Object show all
Includes:
Methods
Defined in:
lib/wedge/component.rb

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Methods

#client?, included, #server?

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Object 



392
393
394
395
396
397
398
 
# File 'lib/wedge/component.rb', line 392

def method_missing(method, *args, &block)
  if config.scope.respond_to?(method, true)
    config.scope.send method, *args, &block
  else
    super
  end
end

Class Attribute Details

.wedge_on_count ⇒ Object

Returns the value of attribute wedge_on_count.



10
11
12
 
# File 'lib/wedge/component.rb', line 10

def wedge_on_count
  @wedge_on_count
end

Instance Attribute Details

#wedge_method_called ⇒ Object Also known as: method_called

Returns the value of attribute wedge_method_called.



7
8
9
 
# File 'lib/wedge/component.rb', line 7

def wedge_method_called
  @wedge_method_called
end

Class Method Details

.config ⇒ Object 



127
128
129
 
# File 'lib/wedge/component.rb', line 127

def wedge_config
  @wedge_config ||= Config.new klass: self, scope: Wedge.config.scope
end

.dom ⇒ Object 



122
123
124
125
126
127
128
129
130
131
 
# File 'lib/wedge/component.rb', line 122

def wedge_dom &block

  unless RUBY_ENGINE == 'opal'
    if block_given?
      yield
    end
  end

  @wedge_dom ||= DOM.new wedge_config.html
end

.html ⇒ Object 



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

def wedge_html(html = '', &block)
  unless RUBY_ENGINE == 'opal'
    wedge_config.html = begin
      File.read html
    rescue
      (html.is_a?(HTML::DSL) || html.is_a?(DOM)) ? html.to_html : html
    end.strip

    if block_given?
      yield
    end
  end
end

.html!(&b) ⇒ Object 



247
248
249
 
# File 'lib/wedge/component.rb', line 247

def html!(&b)
  Wedge.html!(self, &b)
end

.method_missing(method, *args, &block) ⇒ Object 



142
143
144
145
146
147
148
 
# File 'lib/wedge/component.rb', line 142

def method_missing(method, *args, &block)
  if wedge_config.scope.respond_to?(method, true)
    wedge_config.scope.send method, *args, &block
  else
    super
  end
end

.plugin(*args) ⇒ Object 



40
41
42
 
# File 'lib/wedge/component.rb', line 40

def plugin *args
  Wedge.plugin *args
end

.set_dom(dom) ⇒ Object 



243
244
245
 
# File 'lib/wedge/component.rb', line 243

def set_dom dom
  @wedge_dom = dom.is_a?(Wedge::DOM) ? dom : Wedge::DOM.new(dom)
end

.store ⇒ Object 



251
252
253
 
# File 'lib/wedge/component.rb', line 251

def store
  wedge_config.store
end

.tmpl ⇒ Object

Set templates

Examples:

tmpl :some_name, dom.find('#some-div')


110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/wedge/component.rb', line 110

def wedge_tmpl(name, dom = false, remove = true)
  if dom
    dom = remove ? dom.remove : dom
    wedge_config.tmpl[name] = {
      dom:  dom,
      html: dom.to_html
    }
  elsif t = wedge_config.tmpl[name]
    dom = DOM.new t[:html]
  else
    false
  end

  dom
end

.wedge_config ⇒ Object 



124
125
126
 
# File 'lib/wedge/component.rb', line 124

def wedge_config
  @wedge_config ||= Config.new klass: self, scope: Wedge.config.scope
end

.wedge_dom(&block) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
 
# File 'lib/wedge/component.rb', line 112

def wedge_dom &block

  unless RUBY_ENGINE == 'opal'
    if block_given?
      yield
    end
  end

  @wedge_dom ||= DOM.new wedge_config.html
end

.wedge_html(html = '', &block) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/wedge/component.rb', line 75

def wedge_html(html = '', &block)
  unless RUBY_ENGINE == 'opal'
    wedge_config.html = begin
      File.read html
    rescue
      (html.is_a?(HTML::DSL) || html.is_a?(DOM)) ? html.to_html : html
    end.strip

    if block_given?
      yield
    end
  end
end

.wedge_name(*args) ⇒ Object Also known as: name 



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/wedge/component.rb', line 45

def wedge_name(*args)
  if args.any?
    unless RUBY_ENGINE == 'opal'
      # set the file path
      path = "#{caller[0]}".gsub(/(?<=\.rb):.*/, '')
        .gsub(%r{(#{Dir.pwd}/#{Wedge.config.app_dir}/|.*(?=wedge))}, '')
        .gsub(/\.rb$/, '')
    end

    @wedge_on_count = 0

    args.each do |name|
      # set the name
      wedge_config.name = name

      unless RUBY_ENGINE == 'opal'
        # set the file path
        wedge_config.path = path
        # add it to the component class list allow path or name
        Wedge.config.component_class[path.gsub(/\//, '__')] = self
      end

      Wedge.config.component_class[name] = self
    end
  else
    original_name
  end
end

.wedge_new(klass, *args, &block) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/wedge/component.rb', line 12

def wedge_new(klass, *args, &block)
  obj = allocate

  # discuss: come up with something better
  obj.wedge_method_called = klass.method_called

  %w(store scope).each do |meth|
    if value = klass.send(meth)
      obj.config.send "#{meth}=", value
    end
  end

  unless RUBY_ENGINE == 'opal'
    obj.config.on_compile.each do |blk|
      obj.instance_exec &blk
    end
  end

  if args.length > 0
    obj.config.initialize_args = args
    obj.send :initialize, *args, &block
  else
    obj.send :initialize, &block
  end

  obj
end

.wedge_on(*args, &block) ⇒ Object Also known as: on 



129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/wedge/component.rb', line 129

def wedge_on(*args, &block)
  case args.first.to_s
  when 'server'
    wedge_on_server(&block)
  when 'compile'
    wedge_config.on_compile << block unless RUBY_ENGINE == 'opal'
  else
    @wedge_on_count += 1
    Wedge.events.add(config.name, *args, &block)
  end
end

.wedge_on_server(&block) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/wedge/component.rb', line 150

def wedge_on_server(&block)
  if server?
    m = Module.new(&block)

    yield

    m.public_instance_methods(false).each do |meth|
      config.server_methods << meth.to_s

      alias_method :"wedge_on_server_#{meth}", :"#{meth}"
      define_method "#{meth}" do |*args, &blk|
        o_name = "wedge_on_server_#{meth}"

        if method(o_name).parameters.length > 0
          result = send(o_name, *args, &block)
        else
          result = send(o_name, &block)
        end

        blk ? blk.call(result) : result
      end
    end
  else
    m = Module.new(&block)

    m.public_instance_methods(false).each do |meth|
      config.server_methods << meth.to_s

      define_method "#{meth}" do |*args, &blk|
        path_name = config.path

        payload = config.client_data.reject do |k, _|
          %w(html tmpl requires plugins object_events js_loaded).include? k
        end
        payload[:__wedge_name__]   = payload[:name]
        payload[:__wedge_method__] = meth
        payload[:__wedge_args__]   = args

        # we want to remove the assets key from the call so we don't get
        # an error if they assets_key has changed and the user hasn't
        # refreshed the browser yet.
        call_url = "#{Wedge.assets_url.sub("#{Wedge.config.assets_key}/",'')}/#{path_name}.call"

        if block_given?
          HTTP.post(call_url,
            headers: {
              'X-CSRF-TOKEN' => Element.find('meta[name=_csrf]').attr('content'),
              'X-WEDGE-METHOD-REQUEST' => meth
            },
            payload: payload) do |response|

              # We set the new csrf token
              xhr  = Native(response.xhr)
              # discuss: I don't think we should update the csrf token every ajax call
              # csrf = xhr.getResponseHeader('WEDGE-CSRF-TOKEN')
              # Element.find('meta[name=_csrf]').attr 'content', csrf
              ###########################

              res = JSON.from_object(`response`)

              blk.call res[:body], res
          end
        else
          data = {
            headers: {
             'X-CSRF-TOKEN' => "#{Element.find('meta[name=_csrf]').attr('content')}",
             'X-WEDGE-METHOD-REQUEST' => meth
            },
            dataType: 'json',
            type: 'POST',
            url: call_url,
            data: payload,
            async: false
          }.to_n

          response = `$.ajax(data).responseText`
          begin
            JSON.parse response
          rescue
            if response.empty?
              raise "Ajax response to #{call_url} was empty."
            else
              puts response
            end
          end
        end
      end
    end

    include m
  end
end

.wedge_tmpl(name, dom = false, remove = true) ⇒ Object

Set templates

Examples:

tmpl :some_name, dom.find('#some-div')


95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/wedge/component.rb', line 95

def wedge_tmpl(name, dom = false, remove = true)
  if dom
    dom = remove ? dom.remove : dom
    wedge_config.tmpl[name] = {
      dom:  dom,
      html: dom.to_html
    }
  elsif t = wedge_config.tmpl[name]
    dom = DOM.new t[:html]
  else
    false
  end

  dom
end

Instance Method Details

#to_js(method = false, *args) ⇒ Object 



380
381
382
383
384
385
 
# File 'lib/wedge/component.rb', line 380

def to_js(method = false, *args)
  response = args.any? ? send(method, *args) : send(method)
  response = response.to_html if response.is_a? DOM
  response << wedge_javascript(method, *args) if response.is_a? String
  response
end

#wedge(*args, &block) ⇒ Object

We want the scope to override this method if defined



257
258
259
260
261
262
 
# File 'lib/wedge/component.rb', line 257

def wedge(*args, &block)
  # fix: can't pass block to Wedge, opal error:
  # https://github.com/opal/opal/issues/959
  # scope.respond_to?(:wedge) ? scope.wedge(*args, &block) : Wedge[*args, &block]
  scope.respond_to?(:wedge) ? scope.wedge(*args, &block) : Wedge[*args]
end

#wedge_class_store ⇒ Object Also known as: class_store 



279
280
281
 
# File 'lib/wedge/component.rb', line 279

def wedge_class_store
  self.class.wedge_config.store
end

#wedge_config ⇒ Object Also known as: config

Duplicate of class condig [Config]



286
287
288
 
# File 'lib/wedge/component.rb', line 286

def wedge_config
  @wedge_config ||= Config.new(self.class.wedge_config.data.deep_dup)
end

#wedge_dom ⇒ Object Also known as: dom

Dom



300
301
302
303
304
305
306
307
308
 
# File 'lib/wedge/component.rb', line 300

def wedge_dom
  @wedge_dom ||= begin
    if server?
      DOM.new self.class.wedge_dom.to_html
    else
      DOM.new(Element)
    end
  end
end

#wedge_from_client? ⇒ Boolean Also known as: from_client?

Returns:

  • (Boolean) 


348
349
350
351
352
353
354
 
# File 'lib/wedge/component.rb', line 348

def wedge_from_client?
  begin
    wedge_method_called == caller_locations(1,1)[0].label
  rescue
    false
  end
end

#wedge_from_server? ⇒ Boolean Also known as: from_server?

Returns:

  • (Boolean) 


337
338
339
340
341
342
343
 
# File 'lib/wedge/component.rb', line 337

def wedge_from_server?
  begin
    !(wedge_method_called == caller_locations(1,1)[0].label)
  rescue
    true
  end
end

#wedge_function(*args, &block) ⇒ Object Also known as: function

Special method that acts like the javascript equivalent

Examples:

foo = {
  bar: function { |moo|
    moo.call 'something'
  }
}.to_n


318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/wedge/component.rb', line 318

def wedge_function(*args, &block)
  args.any? && raise(ArgumentError, '`function` does not accept arguments')
  block || raise(ArgumentError, 'block required')
  proc do |*a|
    a.map! {|x| Native(`x`)}
    @this = Native(`this`)
    %x{
     var bs = block.$$s,
        result;
      block.$$s = null;
      result = block.apply(self, a);
      block.$$s = bs;

      return result;
    }
  end
end

#wedge_html(&b) ⇒ Object Also known as: html! 



387
388
389
 
# File 'lib/wedge/component.rb', line 387

def wedge_html(&b)
  Wedge.html!(self, &b)
end

#wedge_javascript(method = false, *args) ⇒ Object Also known as: javscript 



357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
 
# File 'lib/wedge/component.rb', line 357

def wedge_javascript(method = false, *args)
  return unless server?

  client_data = config.client_data.dup
  client_data.merge!(
    method_called: method,
    method_args: args,
    initialize_args: config.initialize_args
  )

  compiled_opts = Base64.encode64 client_data.to_json
  javascript = <<-JS
    Wedge.javascript('#{config.path}', JSON.parse(Base64.decode64('#{compiled_opts}')))
  JS
  "<script>#{Opal.compile(javascript)}</script>"
end

#wedge_plugin(name, *args, &block) ⇒ Object

We want the scope to override this method if defined



265
266
267
 
# File 'lib/wedge/component.rb', line 265

def wedge_plugin(name, *args, &block)
  scope.respond_to?(:wedge_plugin) ? scope.wedge_plugin(*args, &block) : wedge("#{name}_plugin", *args, &block)
end

#wedge_scope ⇒ Object Also known as: scope 



269
270
271
 
# File 'lib/wedge/component.rb', line 269

def wedge_scope
  wedge_config.scope
end

#wedge_store ⇒ Object Also known as: store 



274
275
276
 
# File 'lib/wedge/component.rb', line 274

def wedge_store
  wedge_config.store
end

#wedge_tmpl(name) ⇒ Object Also known as: tmpl

Grab a copy of the template



293
294
295
 
# File 'lib/wedge/component.rb', line 293

def wedge_tmpl(name)
  self.class.wedge_tmpl name
end

#wedge_trigger(event_name, *args) ⇒ Object Also known as: trigger 



375
376
377
 
# File 'lib/wedge/component.rb', line 375

def wedge_trigger(event_name, *args)
  Wedge.events.trigger config.name, event_name, *args
end