Module: Opal::Connect::ConnectPlugins::Base::ClassMethods

Included in:
Opal::Connect
Defined in:
lib/opal/connect.rb

Instance Method Summary collapse

Instance Method Details

#files ⇒ Object 



210
211
212
 
# File 'lib/opal/connect.rb', line 210

def files
  @files ||= []
end

#javascript(klass, method, *opts) ⇒ Object 



214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/opal/connect.rb', line 214

def javascript(klass, method, *opts)
  return unless klass

  js = []
  options[:javascript].uniq.each { |block| js << klass.instance_exec(&block) }

  %{
    Document.ready? do
      #{js.join(';')}
      klass = #{klass.class.name}.new
      klass.__send__(:#{method}, *JSON.parse(Base64.decode64('#{Base64.encode64 opts.to_json}'))) if klass.respond_to?(:#{method})
    end
  }
end

#plugin(plugin, *args, &block) ⇒ Object

Load a new plugin into the current class. A plugin can be a module which is used directly, or a symbol represented a registered plugin which will be required and then used. Returns nil.

Connect.plugin PluginModule
Connect.plugin :csrf

Raises:



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
 
# File 'lib/opal/connect.rb', line 177

def plugin(plugin, *args, &block)
  included = (args.first == :included) ? args.shift : false

  raise ConnectError, "Cannot add a plugin to a frozen Connect class" if RUBY_ENGINE != 'opal' && frozen?

  if plugin.is_a?(Symbol)
    Connect.options[:plugins] << plugin unless Connect.options[:plugins].include? plugin
    plugin = ConnectPlugins.load_plugin(plugin)
  end

  plugin.load_dependencies(self, *args, &block) if !included && plugin.respond_to?(:load_dependencies)

  return unless plugin

  include(plugin::InstanceMethods) if defined?(plugin::InstanceMethods)
  extend(plugin::ClassMethods)     if defined?(plugin::ClassMethods)

  unless included
    Connect.extend(plugin::ConnectClassMethods) if defined?(plugin::ConnectClassMethods)
    Connect.include(plugin::ConnectInstanceMethods) if defined?(plugin::ConnectInstanceMethods)
    Connect.instance_exec(plugin, &plugin::ConnectSetup) if defined?(plugin::ConnectSetup)

    unless RUBY_ENGINE == 'opal'
      Connect.options[:javascript] << plugin::ConnectJavascript if defined?(plugin::ConnectJavascript)
    end
  end

  plugin.configure(self, *args, &block) if !included && plugin.respond_to?(:configure)

  nil
end

#plugin_paths ⇒ Object 



252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/opal/connect.rb', line 252

def plugin_paths
  plugins_path   = Connect.options[:plugins_path]
  plugins        = []

  ConnectPlugins.plugins.each do |name, _|
    if plugins_path && File.exist?("#{plugins_path}/#{name}.rb")
      plugins << "#{plugins_path}/#{name}"
    else
      plugins << "opal/connect/plugins/#{name}"
    end
  end

  Connect.options[:requires].each { |plugin_path| plugins << plugin_path }

  plugins
end

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



155
156
157
 
# File 'lib/opal/connect.rb', line 155

def render(method, *args, &block)
  new.render(method, *args, &block)
end

#setup(&block) ⇒ Object 



159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/opal/connect.rb', line 159

def setup(&block)
  if block_given?
    @_setup_block = block
    Connect.options[:setup_blocks] << {
      block: @_setup_block,
      klass: self
    }
  end

  @_setup_block
end

#write_entry_file(klass = false, method = false, *options) ⇒ Object 



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
 
# File 'lib/opal/connect.rb', line 229

def write_entry_file(klass = false, method = false, *options)
  path           = "#{Dir.pwd}/.connect/entry.rb"
  files          = Connect.files.dup.uniq.map { |file| "require '#{file}'" }.join(';')
  entry          = Connect.options[:entry]
  client_options = Base64.encode64 Connect.client_options.to_json
  plugins        = plugin_paths.dup.map { |plugin_path| plugin_path = "require '#{plugin_path}'" }.join(';')

  code = %{
    require 'opal/connect'
    #{plugins}
    options = JSON.parse(Base64.decode64('#{client_options}'))
    options.each { |key, value| Opal::Connect.options[key] = value }
    #{entry}
    #{files}
    # make sure we include the default plugins with connect
    Opal::Connect.options[:plugins].each { |plug| Opal::Connect.plugin plug }
    Opal::Connect.setup
  }

  FileUtils.mkdir_p(File.dirname(path))
  File.write(path, code)
end