wedgeio 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b5ef8331c8e2f16ac456cb505444d1e3216c6c4
+  data.tar.gz: 4428bcba77f4bac04352eef544889d1c406db4ae
+SHA512:
+  metadata.gz: 74a76dc6fd77a6290920a74a4ddc8e38835904a7225c0a35233ec5ab32025b007b053f2a8f388344253ba4857b484cd8b087880f3004a3d7bc2d251b8dcd3651
+  data.tar.gz: 92b1d152855d4d71b19f38585f9e0108f231828742ebb16165f0567176d5247a7963f7a081777cb14159a674c1fe3012a3f5a0e633968459f2e99ffe22686f25

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in BrowserIO.gemspec
+gemspec
+
+gem 'opal', github: 'opal/opal'
+gem 'opal-jquery', github: 'opal/opal-jquery'
+gem 'thin'
+gem 'roda-bin'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 cj
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# BrowserIO
+
+Components for Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'browserio'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install browserio
+
+## Basic Usage
+
+### Setup
+
+    class BasicComponent < BrowserIO::Component
+      setup do |config|
+        config.name :basic
+      end
+
+      def foo
+        'bar'
+      end
+    end
+
+### Call
+
+    Browser[:basic].foo
+
+### Response
+
+    'bar'
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/BrowserIO/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs << %w(test lib)
+  task.pattern = 'test/**/test_*.rb'
+end
+
+task default: :test

data/lib/roda/plugins/wedge.rb

@@ -0,0 +1,93 @@
+class Roda
+  module RodaPlugins
+    module Wedge
+      def self.configure(app, opts = {})
+        if app.opts[:wedge]
+          app.opts[:wedge].merge!(opts)
+        else
+          app.opts[:wedge] = opts.dup
+        end
+
+        opts = app.opts[:wedge]
+
+        opts.each do |k, v|
+          case k.to_s
+          when 'plugins'
+            v.each { |p| ::Wedge.config.plugin p }
+          when 'scope'
+            begin
+              ::Wedge.config.scope v.new
+            rescue
+              ::Wedge.config.scope v.new('')
+            end
+          else
+            ::Wedge.config.send(k, v)
+          end
+        end
+      end
+
+      module InstanceMethods
+        def wedge(*args)
+          args << { scope: self }
+          ::Wedge[*args]
+        end
+      end
+
+      module RequestClassMethods
+        def wedge_route_regex
+          assets_url = ::Wedge.assets_url.gsub(%r{^(http://[^\/]*\/|\/)}, '')
+          %r{#{assets_url}/(.*)\.(.*)$}
+        end
+      end
+
+      module RequestMethods
+        def wedge_assets
+          on self.class.wedge_route_regex do |component, ext|
+            case ext
+            when 'map'
+              ::Wedge.source_map component
+            when 'rb'
+              if component =~ /^wedge/
+                path = ::Wedge.opts.file_path.gsub(/\/wedge.rb$/, '')
+                File.read("#{path}/#{component}.rb")
+              else
+                File.read("#{ROOT_PATH}/#{component}.rb")
+              end
+            when 'call'
+              body = scope.request.body.read
+              data = scope.request.params
+
+              begin
+                data.merge!(body ? JSON.parse(body) : {})
+              rescue
+                # can't be parsed by json
+              end
+
+              data          = data.indifferent
+              name          = data.delete(:name)
+              method_called = data.delete(:method_called)
+              method_args   = data.delete(:method_args)
+
+              res = scope.wedge(name, data).send(method_called, *method_args) || ''
+
+              scope.response.headers["BIO-CSRF-TOKEN"] = scope.csrf_token if scope.methods.include? :csrf_token
+
+              if res.is_a? Hash
+                scope.response.headers["Content-Type"] = 'application/json; charset=UTF-8'
+                res = res.to_json
+              else
+                res = res.to_s
+              end
+
+              res
+            else
+              "#{::Wedge.javascript(component)}\n//# sourceMappingURL=/assets/wedge/#{component}.map"
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:wedge, Wedge)
+  end
+end

data/lib/wedge.rb

@@ -0,0 +1,238 @@
+require 'wedge/opal'
+require 'wedge/version'
+require 'wedge/utilis/indifferent_hash'
+require 'wedge/utilis/hash'
+require 'wedge/utilis/blank'
+require 'wedge/utilis/methods'
+require 'wedge/utilis/try'
+require 'wedge/utilis/titleize'
+require 'wedge/utilis/element'
+require 'base64'
+unless RUBY_ENGINE == 'opal'
+  require 'nokogiri'
+  require 'wedge/utilis/nokogiri'
+end
+require 'wedge/html'
+require 'wedge/dom'
+require 'wedge/config'
+require 'wedge/component'
+
+module Wedge
+  include Methods
+
+  class << self
+    attr_accessor :requires, :loaded_requires, :loaded_requires_events, :javascript_cache,
+      :wedge_javascript_loaded
+
+    def cache
+      javascript
+    end
+
+    def assets_url
+      "#{opts.assets_url}#{opts.cache_assets ? "/#{opts.assets_key}" : ''}"
+    end
+
+    def script_tag
+      "<script src='#{assets_url}/wedge.js'></script>"
+    end
+
+    # 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.
+    def [](name, *args)
+      component = components[name.to_sym]
+
+      component.klass.new(*args)
+    end
+
+    def components
+      @components ||= OpenStruct.new
+    end
+
+    unless RUBY_ENGINE == 'opal'
+      # Returns the build object for opal.
+      #
+      # @param path [String] require path to file to build.
+      # @return [String, Opal::Builder#build]
+      def build(path = 'wedge', options = {})
+        append_paths
+        Opal::Builder.build(path, options)
+      end
+
+      # Source maps for the javascript
+      def source_map(path = 'wedge', options = {})
+        build(path, options).source_map
+      end
+
+      # Append the correct paths to opal.
+      #
+      # @return [Array] List of opal paths.
+      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
+    end
+
+    # Return the opal javascript.
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    # Used to setup the component with default options.
+    #
+    # @example
+    #   class SomeComponent < Component
+    #     setup do |config|
+    #       config.name :some
+    #     end
+    #   end
+    # @yield [Config]
+    def setup(&block)
+      block.call config if block_given?
+    end
+
+    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
+
+    def opts
+      config.opts
+    end
+  end
+end