module Wedge

Constants

Form
Opal

Create our own opal instance.

VERSION

Attributes

javascript_cache[RW]
loaded_requires[RW]
loaded_requires_events[RW]
requires[RW]
wedge_javascript_loaded[RW]

Public Class Methods

[](name, *args) click to toggle source

Used to call a component.

@example

Browser[:foo].bar

@param name [String, Symbol, to_s] The unique name given to a component. @return [Wedge::Component#method] Last line of the method called.

# File lib/wedge.rb, line 46
def [](name, *args)
  component = components[name.to_sym]

  component.klass.new(*args)
end
append_paths() click to toggle source

Append the correct paths to opal.

@return [Array] List of opal paths.

# File lib/wedge.rb, line 74
def append_paths
  @append_paths ||= begin
    file = method(:components).source_location.first.sub('/wedge.rb', '')
    Wedge::Opal.append_path file
    Wedge::Opal.append_path Dir.pwd
  end
end
assets_url() click to toggle source
# File lib/wedge.rb, line 31
def assets_url
  "#{opts.assets_url}#{opts.cache_assets ? "/#{opts.assets_key}" : ''}"
end
build(path = 'wedge', options = {}) click to toggle source

Returns the build object for opal.

@param path [String] require path to file to build. @return [String, Opal::Builder#build]

# File lib/wedge.rb, line 61
def build(path = 'wedge', options = {})
  append_paths
  Opal::Builder.build(path, options)
end
cache() click to toggle source
# File lib/wedge.rb, line 27
def cache
  javascript
end
components() click to toggle source
# File lib/wedge.rb, line 52
def components
  @components ||= OpenStruct.new
end
config() click to toggle source
# File lib/wedge.rb, line 221
def config
  @config ||= begin
    args = { klass: self }

    unless RUBY_ENGINE == 'opal'
      args[:file_path]  = caller.first.gsub(/(?<=\.rb):.*/, '')
      args[:assets_key] = ENV.fetch('SOURCE_VERSION') { `git rev-parse HEAD 2>/dev/null`.to_s.strip }
    end

    Config.new(args)
  end
end
get_requires(reqs, requires_array = []) click to toggle source
# File lib/wedge.rb, line 177
def get_requires reqs, requires_array = []
  new_reqs = []

  reqs.each do |r|
    if r[:requires].any?
      get_requires(r[:requires], requires_array)
    end

    new_reqs << r
  end

  requires_array << new_reqs if new_reqs.any?

  requires_array
end
javascript(path_name = 'wedge', options = {}, promise = false) click to toggle source

Return the opal javascript.

# File lib/wedge.rb, line 84
def javascript(path_name = 'wedge', options = {}, promise = false)
  if server?
    if path_name == 'wedge'
      @wedge_javascript ||= begin
        @wedge_javascript_loaded = true
        requires = {}

        @javascript_cache ||= {}

        components.to_h.each do |k, v|
          requires[k] = v.klass.wedge_config.get_requires
          javascript(v.klass.wedge_opts[:path_name])
        end

        compiled_requires = Base64.encode64 requires.to_json
        assets_key        = opts.assets_key
        cache_assets      = opts.cache_assets

        js = build(path_name, options).javascript
        js << Opal.compile("Wedge.instance_variable_set(:@requires, JSON.parse(Base64.decode64('#{compiled_requires}')))")
        # fix: we need to just merge in all config opts and just reject
        # certain ones
        js << Opal.compile("Wedge.config.assets_key('#{assets_key}')") if assets_key
        js << Opal.compile("Wedge.config.cache_assets('#{cache_assets}')") if cache_assets
        ##############################################################
        js
      end
    else
      @javascript_cache[path_name] ||= begin
        js = build(path_name, options).javascript
        comp_name = components.to_h.select { |k, v| v.path_name == path_name }.first.last.name
        comp = Wedge[comp_name]
        options = comp.client_wedge_opts
        compiled_opts = Base64.encode64 options.to_json
        js << Opal.compile("Wedge.components[:#{comp_name}].klass.instance_variable_set(:@wedge_config, Wedge::Config.new(Wedge.components[:#{comp_name}].klass.wedge_config.opts_dup.merge(JSON.parse(Base64.decode64('#{compiled_opts}')))))")
      end
    end
  else
    Wedge.loaded_requires ||= []
    Wedge.loaded_requires_events ||= []
    reqs     = Wedge.requires[options[:name].to_sym].dup
    promise  = Promise.new
    requires = get_requires(reqs)

    load_requires(requires.dup, promise)

    promise.then do
      load_comp(options).then do
        method_called = options[:method_called]
        method_args   = options[:method_args]
        name          = options[:name]
        comp          = Wedge[name, options]

        Document.ready? do
          trigger_requires_events requires.dup
          comp.send(method_called, *method_args) if method_called
          comp.wedge_trigger :browser_events
        end
      end
    end
  end
end
load_comp(options = {}) click to toggle source
# File lib/wedge.rb, line 193
def load_comp options = {}, promise = Promise.new
  path_name  = options[:path_name]
  assets_url = Wedge.assets_url

  # fix: this could give people unwanted behaviour, change getScript to just
  # use ajax.
  `jQuery.ajaxSetup({ cache: true })` if Wedge.opts.cache_assets
  `$.getScript(assets_url + "/" + path_name + ".js").done(function(){`
    promise.resolve true
  `}).fail(function(jqxhr, settings, exception){ window.console.log(exception); });`
  #########################################################################

  promise
end
load_requires(requires, promise = Promise.new) click to toggle source
# File lib/wedge.rb, line 160
def load_requires requires, promise = Promise.new
  reqs     = requires.shift
  promises = []

  reqs.each do |r|
    next if Wedge.loaded_requires.include? r[:name]

    Wedge.loaded_requires << r[:name]

    promises << -> { load_comp r }
  end

  Promise.when(*promises.map!(&:call)).then do
    requires.any?? load_requires(requires, promise) : promise.resolve(true)
  end
end
opts() click to toggle source
# File lib/wedge.rb, line 234
def opts
  config.opts
end
script_tag() click to toggle source
# File lib/wedge.rb, line 35
def script_tag
  "<script src='#{assets_url}/wedge.js'></script>"
end
setup(&block) click to toggle source

Used to setup the component with default options.

@example

class SomeComponent < Component
  setup do |config|
    config.name :some
  end
end

@yield [Config]

# File lib/wedge.rb, line 217
def setup(&block)
  block.call config if block_given?
end
source_map(path = 'wedge', options = {}) click to toggle source

Source maps for the javascript

# File lib/wedge.rb, line 67
def source_map(path = 'wedge', options = {})
  build(path, options).source_map
end
trigger_requires_events(requires) click to toggle source
# File lib/wedge.rb, line 147
def trigger_requires_events requires
  reqs = requires.shift

  reqs.each do |r|
    next if Wedge.loaded_requires_events.include? r[:name]
    Wedge.loaded_requires_events << r[:name]
    comp = Wedge[r[:name], r]
    comp.wedge_trigger :browser_events
  end

  trigger_requires_events requires if requires.any?
end