Module: Wedge

Includes:
Methods
Defined in:
lib/wedge.rb,
lib/wedge/dom.rb,
lib/wedge/html.rb,
lib/wedge/opal.rb,
lib/wedge/config.rb,
lib/wedge/events.rb,
lib/wedge/version.rb,
lib/wedge/component.rb,
lib/wedge/plugins/form.rb,
lib/wedge/plugins/pjax.rb,
lib/wedge/utilis/methods.rb,
lib/wedge/plugins/history.rb,
lib/wedge/plugins/validations.rb,
lib/wedge/utilis/indifferent_hash.rb

Defined Under Namespace

Modules: HTML, Methods, Plugins Classes: Component, Config, DOM, Events, IndifferentHash

Constant Summary collapse

Opal =

Create our own opal instance.

::Opal.dup
VERSION = 
'0.0.26'
Form = 
Wedge::Plugins::Form

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Methods

#client?, included, #server?

Class Attribute Details

.browser_events ⇒ Object

Returns the value of attribute browser_events.



24
25
26
 
# File 'lib/wedge.rb', line 24

def browser_events
  @browser_events
end

.events_triggered ⇒ Object

Returns the value of attribute events_triggered.



24
25
26
 
# File 'lib/wedge.rb', line 24

def events_triggered
  @events_triggered
end

.javascript_cache ⇒ Object

Returns the value of attribute javascript_cache.



24
25
26
 
# File 'lib/wedge.rb', line 24

def javascript_cache
  @javascript_cache
end

.loaded_requires ⇒ Object

Returns the value of attribute loaded_requires.



24
25
26
 
# File 'lib/wedge.rb', line 24

def loaded_requires
  @loaded_requires
end

.loaded_requires_events ⇒ Object

Returns the value of attribute loaded_requires_events.



24
25
26
 
# File 'lib/wedge.rb', line 24

def loaded_requires_events
  @loaded_requires_events
end

.object_events ⇒ Object

Returns the value of attribute object_events.



24
25
26
 
# File 'lib/wedge.rb', line 24

def object_events
  @object_events
end

.requires ⇒ Object

Returns the value of attribute requires.



24
25
26
 
# File 'lib/wedge.rb', line 24

def requires
  @requires
end

.wedge_javascript_loaded ⇒ Object

Returns the value of attribute wedge_javascript_loaded.



24
25
26
 
# File 'lib/wedge.rb', line 24

def wedge_javascript_loaded
  @wedge_javascript_loaded
end

Class Method Details

.[](name, *args) ⇒ Wedge::Component#method

Used to call a component.

Examples:

Browser[:foo].bar

Parameters:

  • name (String, Symbol, #to_s) —

    The unique name given to a component.

Returns:



51
52
53
54
55
 
# File 'lib/wedge.rb', line 51

def [](name, *args)
  component = components[name.to_sym]

  component.klass.new(*args)
end

.assets_url ⇒ Object 



31
32
33
34
 
# File 'lib/wedge.rb', line 31

def assets_url
  url = opts.assets_url.gsub(%r{^(http(|s)://[^\/]*\/|\/)}, '/')
  "#{url}#{opts.cache_assets ? "/#{opts.assets_key}" : ''}"
end

.assets_url_with_host ⇒ Object 



36
37
38
 
# File 'lib/wedge.rb', line 36

def assets_url_with_host
  "#{opts.assets_url}#{opts.cache_assets ? "/#{opts.assets_key}" : ''}"
end

.compile_opal ⇒ Object 



27
28
29
 
# File 'lib/wedge.rb', line 27

def compile_opal
  javascript
end

.components ⇒ Object 



57
58
59
 
# File 'lib/wedge.rb', line 57

def components
  @components ||= OpenStruct.new
end

.config ⇒ Object 



257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
 
# File 'lib/wedge.rb', line 257

def config
  @config ||= begin
    args = { klass: self }

    unless RUBY_ENGINE == 'opal'
      args[:file_path]  = caller.first.gsub(/(?<=\.rb):.*/, '')
      args[:assets_key] = begin
        if defined?(PlatformAPI) && ENV['HEROKU_TOKEN'] && ENV['HEROKU_APP']
          heroku = PlatformAPI.connect_oauth(ENV['HEROKU_TOKEN'], default_headers: {'Range' => 'version ..; order=desc'})
          slug_id = heroku.release.list(ENV['HEROKU_APP']).first["slug"]["id"]
          heroku.slug.info(ENV['HEROKU_APP'], slug_id)["commit"]
        else
          `git rev-parse HEAD 2>/dev/null`.to_s.strip
        end
      end
    end

    Config.new(args)
  end
end

.get_requires(reqs, requires_array = []) ⇒ Object 



209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/wedge.rb', line 209

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) ⇒ Object

Return the opal javascript.



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
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
 
# File 'lib/wedge.rb', line 93

def javascript(path_name = 'wedge', options = {}, promise = false)
  if server?
    if path_name == 'wedge'
      @wedge_javascript ||= begin
        @wedge_javascript_loaded = true
        requires      = {}
        @object_events = {}
        @browser_events = {}

        @javascript_cache ||= {}

        components.to_h.each do |k, v|
          requires[k]      = v.klass.wedge_config.get_requires
          # events = Wedge[v.name].wedge_opts.events
          # @object_events[v.name]  = events.object_events
          # @browser_events[v.name] = events.browser_events
          javascript(v.klass.wedge_opts[:path_name])
        end

        compiled_requires = Base64.encode64 requires.to_json
        # compiled_object_events = Base64.encode64 object_events.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 << Opal.compile("Wedge.config.assets_url('#{opts.assets_url}')")
        js << Opal.compile("Wedge.config.assets_url_with_host('#{opts.assets_url_with_host}')")
        ##############################################################
        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.events_triggered ||= []
    Wedge.loaded_requires ||= []
    Wedge.loaded_requires_events ||= []
    reqs     = Wedge.requires[options[:name].to_sym]
    promise  = Promise.new

    if reqs
      requires = get_requires(reqs.dup)
      load_requires(requires.dup, promise)
    else
      promise.resolve true
    end

    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
          if method_called && !comp.wedge_opts.on_server_methods.include?(method_called)
            comp.send(method_called, *method_args)
          end

          unless Wedge.events_triggered.include?(name)
            comp.wedge_trigger :browser_events
            Wedge.loaded_requires << name
            Wedge.events_triggered << name
          end

          trigger_requires_events requires.dup
        end
      end
    end
  end
end

.load_comp(options = {}, promise = Promise.new) ⇒ Object 



225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/wedge.rb', line 225

def load_comp options = {}, promise = Promise.new
  path_name  = options[:path_name]
  assets_url = Wedge.assets_url_with_host

  if !Wedge.components[options[:name]]
    # 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); });`
    #########################################################################
  else
    promise.resolve true
  end

  promise
end

.load_requires(requires, promise = Promise.new) ⇒ Object 



192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/wedge.rb', line 192

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 if reqs

  Promise.when(*promises.map!(&:call)).then do
    requires.any?? load_requires(requires, promise) : promise.resolve(true)
  end
end

.opts ⇒ Object 



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

def opts
  config.opts
end

.script_tag ⇒ Object 



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

def script_tag
  "<script src='#{assets_url}/wedge.js'></script>"
end

.setup {|Config| ... } ⇒ Object

Used to setup the component with default options.

Examples:

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

Yields:



253
254
255
 
# File 'lib/wedge.rb', line 253

def setup(&block)
  block.call config if block_given?
end

.trigger_requires_events(requires) ⇒ Object 



177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/wedge.rb', line 177

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
    Wedge.events_triggered << r[:name]
  end

  trigger_requires_events requires if requires.any?
end

Instance Method Details

#append_paths ⇒ Array

Append the correct paths to opal.

Returns:

  • (Array) —

    List of opal paths.



79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/wedge.rb', line 79

def append_paths
  @append_paths ||= begin
    file     = method(:components).source_location.first.sub('/wedge.rb', '')
    gems_dir = ::Opal.gem_dir.gsub(/(?<=gems)\/opal-.*/, '')
    Wedge::Opal.append_path file
    Wedge::Opal.append_path Dir.pwd
    Dir["#{gems_dir}/**/"].sort.each do |folder|
      Wedge::Opal.append_path "#{folder}/lib"
    end
  end
end

#build(path = 'wedge', options = {}) ⇒ String, Opal::Builder#build

Returns the build object for opal.

Parameters:

  • path (String) (defaults to: 'wedge') —

    require path to file to build.

Returns:



66
67
68
69
 
# File 'lib/wedge.rb', line 66

def build(path = 'wedge', options = {})
  append_paths
  Opal::Builder.build(path, options)
end

#source_map(path = 'wedge', options = {}) ⇒ Object

Source maps for the javascript



72
73
74
 
# File 'lib/wedge.rb', line 72

def source_map(path = 'wedge', options = {})
  build(path, options).source_map
end