opal-connect 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7ee622b62ef725481b6c98e606815d1498b4f847
+  data.tar.gz: a27b1855decd4c7af2df0e92974a3be0ee5e9b87
+SHA512:
+  metadata.gz: fd927ee3c2efe5fa14c11bd096b5f4cf261dedf30160ccb269254754941b679e06cc6659d9b9b649221a8a2d3a2120821ab10a7f689027ef39171623644e3ea1
+  data.tar.gz: 33dd26a3bef73247df061b1ed8c52751abd04a58bdb2568fc11be8f8e9ed5f2c785f708366085c952d561f07dee66e17b42e3f061d9e151827ccd5499b4eefc8

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,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in opal-connect.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 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,31 @@
+# Opal::Connect
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'opal-connect'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install opal-connect
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/opal-connect/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,2 @@
+require "bundler/gem_tasks"
+

data/lib/opal/connect/plugins/dom.rb

@@ -0,0 +1,247 @@
+if RUBY_ENGINE != 'opal'
+  require 'oga'
+end
+
+module Opal
+  module Connect
+    module ConnectPlugins
+      # https://github.com/jeremyevans/roda/blob/master/lib/roda.rb#L16
+      # A thread safe cache class, offering only #[] and #[]= methods,
+      # each protected by a mutex.
+      module Dom
+        extend self
+
+        if RUBY_ENGINE != 'opal'
+          def html_file(caller)
+            path = "#{Dir.pwd}/.connect/html/#{caller[0][/[^:]*/].sub(Dir.pwd, '')[1..-1].sub('.rb', '.html')}"
+            FileUtils.mkdir_p(File.dirname(path))
+            path
+          end
+        end
+
+        def html(scope = false, &block)
+          if !block_given?
+            HTML::DSL.html(&scope).to_html
+          else
+            HTML::DSL.scope!(scope).html(&block).to_html
+          end
+        end
+
+        def [](selector)
+          if RUBY_ENGINE == 'opal'
+            file_name = false
+          else
+            file_name = html_file(caller)
+
+            if selector.is_a?(Symbol)
+              file_name = "#{file_name}.#{selector}"
+              selector  = File.read(file_name)
+            end
+          end
+
+          Instance.new selector, file_name
+        end
+
+        class Instance
+          attr_reader :selector, :file_name, :dom
+
+          def initialize(selector, file_name = false)
+            @selector   = selector
+            @file_name  = file_name
+
+            if selector.is_a?(String)
+              if RUBY_ENGINE == 'opal'
+                @dom = Element[selector]
+              else
+                # multi-line
+                if selector["\n"]
+                  @dom = Oga.parse_html(selector)
+                else
+                  @dom = Oga.parse_html(File.read(file_name))
+                  @dom = dom.css(selector) unless selector == 'html'
+                end
+              end
+            else
+              @dom = selector
+            end
+          end
+
+          if RUBY_ENGINE != 'opal'
+            def to_html
+              if node.respond_to?(:first)
+                node.first.to_xml
+              else
+                node.to_xml
+              end
+            end
+
+            def to_s
+              if dom.respond_to?(:first)
+                dom.first.to_xml
+              else
+                dom.to_xml
+              end
+            end
+
+            def save template_name = false, remove = true
+              if template_name
+                File.write("#{file_name}.#{template_name.to_s}", self.to_html)
+                dom.remove if remove
+              else
+                File.write(file_name, self.to_html)
+              end
+            end
+            alias save! save
+
+            def text(content)
+              if node.respond_to?(:inner_text)
+                node.inner_text = content
+              else
+                node.each { |n| n.inner_text = content }
+              end
+
+              self
+            end
+
+            def attr(key, value = false)
+              if value
+                if node.respond_to? :set
+                  node.set(key, value)
+                else
+                  node.each { |n| n.set(key, value) }
+                end
+              else
+                if node.respond_to? :get
+                  node.get(key)
+                else
+                  node.first.get(key)
+                end
+              end
+
+              self
+            end
+
+            def remove
+              if node.respond_to? :remove
+                node.remove
+              else
+                node.each { |n| n.remove }
+              end
+
+              self
+            end
+          end
+
+          def append(content, &block)
+            # content becomes scope in this case
+            content = HTML::DSL.scope!(content).html(&block).to_html if block_given?
+
+            if RUBY_ENGINE == 'opal'
+              node.append(content)
+            else
+              if content.is_a? Dom::Instance
+                content = content.children
+              else
+                content = Oga.parse_html(content).children
+              end
+
+              if node.is_a?(Oga::XML::NodeSet)
+                node.each { |n| n.children = (n.children + content) }
+              else
+                node.children = (children + content)
+              end
+            end
+
+            self
+          end
+
+          def prepend(content, &block)
+            # content becomes scope in this case
+            content = HTML::DSL.scope!(content).html(&block).to_html if block_given?
+
+            if RUBY_ENGINE == 'opal'
+              node.prepend(content)
+            else
+              if content.is_a? Dom::Instance
+                content = content.children
+              else
+                content = Oga.parse_html(content).children
+              end
+
+              if node.is_a?(Oga::XML::NodeSet)
+                node.each { |n| n.children = (content + n.children) }
+              else
+                node.children = (content + children)
+              end
+            end
+
+            self
+          end
+
+          def html(content = false, &block)
+            # content becomes scope in this case
+            content = HTML::DSL.scope!(content).html(&block).to_html if block_given?
+
+            if RUBY_ENGINE == 'opal'
+              node.html(content)
+            else
+              if content.is_a? Dom::Instance
+                content = content.children
+              else
+                content = Oga.parse_html(content).children
+              end
+
+              if node.is_a?(Oga::XML::NodeSet)
+                node.each { |n| n.children = content }
+              else
+                node.children = content
+              end
+            end
+
+            self
+          end
+
+          def find(selector)
+            new_node = if RUBY_ENGINE == 'opal'
+              node.find(selector)
+            else
+              if node.is_a? Oga::XML::NodeSet
+                node.first.css(selector)
+              else
+                node.css(selector)
+              end
+            end
+
+            Instance.new(new_node, file_name)
+          end
+
+          def each
+            node.each { |n| yield Instance.new(n, file_name) }
+          end
+
+          def node
+            if self.is_a?(Dom::Instance)
+              self.dom
+            else
+              dom
+            end
+          end
+
+          # This allows you to use all the oga or opal jquery methods if a
+          # global one isn't set
+          def method_missing(method, *args, &block)
+            if dom.respond_to?(method, true)
+              dom.send(method, *args, &block)
+            else
+              super
+            end
+          end
+        end
+      end
+
+      register_plugin(:dom, Dom)
+    end
+  end
+end
+
+Dom = Opal::Connect::ConnectPlugins::Dom

data/lib/opal/connect/plugins/events.rb

@@ -0,0 +1,69 @@
+module Opal
+  module Connect
+    module ConnectPlugins
+      module Events
+        module ClassMethods
+          if RUBY_ENGINE == 'opal'
+            def connect_events
+              $connect_events[self] ||= []
+            end
+          end
+
+          def connect_el el = false
+            @connect_el = el if el
+            @connect_el
+          end
+
+          def connect_on(name, selector = nil, method = nil, &handler)
+            if RUBY_ENGINE == 'opal'
+              handler = proc { |evt| __send__(method, evt) } if method
+              event = [name, selector, handler]
+              connect_events << event unless connect_events.include? event
+            end
+          end
+        end
+
+        if RUBY_ENGINE == 'opal'
+          module ConnectClassMethods
+            $connect_events = ConnectCache.new unless $connect_events
+
+            def events_teardown
+              if $connect_events
+                $connect_events.each do |klass, events|
+                  el = Dom[klass.connect_el || 'body']
+
+                  events.each do |event|
+                    name, selector, wrapper = event
+                    el.off(name, selector, &wrapper)
+                  end
+                end
+
+                $connect_events = ConnectCache.new
+              end
+            end
+
+            def events_start
+              $connect_events.each do |klass, events|
+                el = Dom[klass.connect_el || 'body']
+
+                events.map! do |event|
+                  name, selector, handler = event
+                  wrapper = proc do |e|
+                    # gives you access to this, like jquery
+                    @this = Dom[e.target]
+                    instance_exec(e, &handler)
+                  end
+
+                  el.on(name, selector, &wrapper)
+                  [name, selector, wrapper]
+                end
+              end
+            end
+          end
+        end
+      end
+
+      register_plugin(:events, Events)
+    end
+  end
+end

data/lib/opal/connect/plugins/html.rb

@@ -0,0 +1,79 @@
+module Opal
+  module Connect
+    module ConnectPlugins
+      module HTML
+        INDENT = '  '
+
+        TAGS = %w{a button abbr acronym address applet area article aside audio b base basefont bdi
+                  bdo big blockquote body br canvas caption center cite code col colgroup command
+                  datalist dd del details dfn dialog dir div dl dt em embed fieldset figcaption
+                  figure font footer form frame frameset h1 head header hgroup hr html i iframe
+                  img input ins kbd keygen label legend li link map mark menu meta meter nav noframes
+                  noscript object ol optgroup option output p param pre progress q rp rt ruby s samp
+                  script section select small source span strike strong style sub summary sup table tbody
+                  td textarea tfoot th thead time title tr track tt u ul var video wbr}
+
+        # http://erikonrails.snowedin.net/?p=379
+        class DSL
+          def initialize(tag, *args, &block)
+            @tag         = tag
+            @content     = args.find { |a| a.instance_of? String }
+            @attributes  = args.find { |a| a.instance_of? Hash }
+            @attr_string = []
+            self.instance_eval(&block) if block_given?
+          end
+
+          def to_html
+            if @tag
+              @attr_string << " #{@attributes.map {|k,v| "#{k}=#{v.to_s.inspect}" }.join(" ")}" if @attributes
+              "<#{@tag}#{@attr_string.join}>#{@content}#{children.map(&:to_html).join}</#{@tag}>"
+            else
+              "#{@content}#{children.map(&:to_html).join}"
+            end
+          end
+
+          def children
+            @children ||= []
+          end
+
+          # Some of these are Kernel or Object methods or whatever that we need to explicitly override
+          [:p, :select].each do |name|
+            define_method name do |*args, &block|
+              send :method_missing, name, *args, &block
+            end
+          end
+
+          def method_missing(tag, *args, &block)
+            if !TAGS.include?(tag.to_s) && scope.respond_to?(tag, true)
+              scope.send(tag, *args, &block)
+            else
+              child = DSL.scope!(scope).new(tag.to_s, *args, &block)
+              children << child
+              child
+            end
+          end
+
+          def scope
+            self.class.scope
+          end
+
+          class << self
+            attr_accessor :scope
+
+            def html &block
+              DSL.scope!(scope).new(nil, nil, &block)
+            end
+
+            def scope! scope
+              klass = Class.new(self)
+              klass.instance_variable_set(:@scope, scope)
+              klass
+            end
+          end
+        end
+      end
+
+      register_plugin(:html, HTML)
+    end
+  end
+end

data/lib/opal/connect/plugins/server.rb

@@ -0,0 +1,65 @@
+module Opal
+  module Connect
+    module ConnectPlugins
+      module Server
+        module ConnectClassMethods
+          def server_methods
+            @server_methods ||= ConnectCache.new
+          end
+
+          def server_methods=(methods)
+            @server_methods = methods
+          end
+        end
+
+        module ClassMethods
+          def connect_server_methods
+            Connect.server_methods[self.name] ||= []
+          end
+
+          def connect_server(m = false, &block)
+            return if RUBY_ENGINE == 'opal'
+
+            m ||= Module.new(&block)
+
+            yield if block_given?
+
+            m.public_instance_methods(false).each do |meth|
+              connect_server_methods << meth unless connect_server_methods.include? meth
+            end
+          end
+        end
+
+        module ConnectInstanceMethods
+          def __connect_server__(method, *args)
+            if Connect.server_methods[self.class.name].include? method
+              promise = Promise.new
+
+              payload = {
+                method: method,
+                args: args,
+                klass: self.class.name
+              }
+
+              HTTP.post('/connect', payload: payload) do |response|
+                if response.ok?
+                  res = JSON.from_object(`response`)
+                  promise.resolve res[:body], response
+                else
+                  promise.reject response
+                end
+              end
+
+              promise
+            else
+              raise "#{method} is not a server method"
+            end
+          end
+          alias connect_server __connect_server__
+        end
+      end
+
+      register_plugin(:server, Server)
+    end
+  end
+end

data/lib/opal/connect/version.rb

@@ -0,0 +1,5 @@
+module Opal
+  module Connect
+    VERSION = "0.0.1"
+  end
+end

data/lib/opal/connect.rb

@@ -0,0 +1,226 @@
+require "opal/connect/version"
+require 'base64'
+
+if RUBY_ENGINE == 'opal'
+  module Kernel
+    def puts(*args)
+      require 'console'
+      $console.log(*args)
+    end
+  end
+end
+
+# Opal corelib is already loaded from CDN
+module Opal
+  module Connect
+    class << self
+      def __options__
+        @options ||= Connect::ConnectCache.new(hot_reload: false)
+
+        yield(@options) if block_given?
+
+        @options
+      end
+      alias options __options__
+
+      def included(klass)
+        if RUBY_ENGINE != 'opal'
+          file = caller[0][/[^:]*/].sub(Dir.pwd, '')[1..-1]
+          files << file unless files.include?(file)
+        end
+
+        klass.extend ConnectPlugins::Base::ClassMethods
+        klass.plugin :server
+        klass.plugin :html
+        klass.plugin :dom
+        klass.plugin :events
+      end
+
+      def write_plugins_file
+        ConnectPlugins.plugins.each do |name, klass|
+          path = klass.instance_methods(false).map { |m|
+            klass.instance_method(m).source_location.first
+          }.uniq
+
+          binding.pry
+        end
+      end
+    end
+
+    class ConnectError < StandardError; end
+
+    class ConnectCache
+      # Create a new thread safe cache.
+      def initialize(options = false)
+        @mutex = Mutex.new if RUBY_ENGINE != 'opal'
+        @hash = options || {}
+      end
+
+      # Make getting value from underlying hash thread safe.
+      def [](key)
+        if RUBY_ENGINE == 'opal'
+          @hash[key]
+        else
+          @mutex.synchronize { @hash[key] }
+        end
+      end
+
+      # Make setting value in underlying hash thread safe.
+      def []=(key, value)
+        if RUBY_ENGINE == 'opal'
+          @hash[key] = value
+        else
+          @mutex.synchronize { @hash[key] = value }
+        end
+      end
+
+      def to_json
+        @mutex.synchronize { @hash.to_json }
+      end
+
+      def each
+        if RUBY_ENGINE == 'opal'
+          @hash.each { |key, value| yield key, value }
+        else
+          @mutex.synchronize do
+            @hash.each { |key, value| yield key, value }
+          end
+        end
+      end
+    end
+
+    module ConnectPlugins
+      @plugins = ConnectCache.new
+
+      def self.plugins
+        @plugins
+      end
+
+      def self.load_plugin(name)
+        h = @plugins
+        unless plugin = h[name]
+          unless RUBY_ENGINE == 'opal'
+            require "opal/connect/plugins/#{name}"
+            raise ConnectError, "Plugin #{name} did not register itself correctly in Roda::RodaPlugins" unless plugin = h[name]
+          end
+        end
+        plugin
+      end
+
+      # Register the given plugin with Roda, so that it can be loaded using #plugin
+      # with a symbol.  Should be used by plugin files. Example:
+      #
+      #   Roda::RodaPlugins.register_plugin(:plugin_name, PluginModule)
+      def self.register_plugin(name, mod)
+        @plugins[name] = mod
+      end
+
+      module Base
+        module InstanceMethods
+          if RUBY_ENGINE != 'opal'
+            def to_js(method, *options)
+              if hl = Connect.options[:hot_reload]
+                hl = {} unless hl.is_a? Hash
+                hl = { host: 'http://localhost', port: 8080 }.merge hl
+
+                Connect.write_entry_file(self.class, method, *options)
+
+                "#{__send__(method, *options)}<script src='#{hl[:host]}:#{hl[:port]}/main.js'></script>"
+              else
+                js = Connect.build Connect.javascript(self.class, method, *options)
+
+                "#{send(method, *options)}<script>#{js}</script>"
+              end
+            end
+          end
+        end
+
+        module ClassMethods
+          def setup(&block)
+            yield
+          end
+
+          # 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
+          def plugin(plugin, *args, &block)
+            raise ConnectError, "Cannot add a plugin to a frozen Connect class" if RUBY_ENGINE != 'opal' && frozen?
+            plugin = ConnectPlugins.load_plugin(plugin) if plugin.is_a?(Symbol)
+            plugin.load_dependencies(self, *args, &block) if plugin.respond_to?(:load_dependencies)
+            include(plugin::InstanceMethods) if defined?(plugin::InstanceMethods)
+            extend(plugin::ClassMethods) if defined?(plugin::ClassMethods)
+            self.extend(plugin::ConnectClassMethods) if defined?(plugin::ConnectClassMethods)
+            self.include(plugin::ConnectInstanceMethods) if defined?(plugin::ConnectInstanceMethods)
+            plugin.configure(self, *args, &block) if plugin.respond_to?(:configure)
+            nil
+          end
+
+          if RUBY_ENGINE != 'opal'
+            def files
+              @files ||= []
+            end
+
+            def build(code)
+              builder = Opal::Builder.new
+
+              builder.build_str(code, '(inline)' \
+                , dynamic_require_severity: :ignore).to_s
+            end
+
+            def javascript(klass, method, *options)
+              if hot_reload = Connect.options[:hot_reload]
+                required_files = Connect.files.map do |file|
+                  "`require('#{file}')`"
+                end.join(';')
+              end
+
+              %{
+                #{!hot_reload ? '' : 'Opal::Connect.events_teardown'}
+                #{!hot_reload ? '' : required_files}
+
+                Opal::Connect.server_methods = JSON.parse(
+                  Base64.decode64('#{Base64.encode64 Connect.server_methods.to_json}')
+                )
+
+                Document.ready? do
+                  klass = #{klass.name}.new
+
+                  if klass.respond_to?(:#{method})
+                    klass.__send__(:#{method}, *JSON.parse(Base64.decode64('#{Base64.encode64 options.to_json}')))
+                  end
+
+                  Opal::Connect.events_start
+                end
+              }
+            end
+
+            def write_entry_file(klass, method, *options)
+              Opal.use_gem 'opal-jquery'
+
+              code = %{
+                `if (module.hot) {`
+                  `module.hot.accept()`
+                  #{Connect.javascript(klass, method, *options)}
+                `}`
+              }
+
+              File.write("#{Dir.pwd}/.connect/entry.js", build(code))
+            end
+          end
+        end
+      end
+    end
+
+    if RUBY_ENGINE == 'opal'
+      require ".connect/plugins"
+    end
+
+    extend ConnectPlugins::Base::ClassMethods
+    plugin ConnectPlugins::Base
+    plugin :server
+    plugin :events
+  end
+end

data/opal-connect.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'opal/connect/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "opal-connect"
+  spec.version       = Opal::Connect::VERSION
+  spec.authors       = ["cj"]
+  spec.email         = ["cjlazell@gmail.com"]
+  spec.summary       = %q{Connects Opal to Ruby.}
+  spec.description   = %q{Connect Opal to Ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "opal", ">= 0.9.2"
+  spec.add_dependency "opal-jquery", ">= 0.4.1"
+  spec.add_dependency "oga", ">= 2.2"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: opal-connect
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- cj
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: opal-jquery
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: oga
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Connect Opal to Ruby.
+email:
+- cjlazell@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/opal/connect.rb
+- lib/opal/connect/plugins/dom.rb
+- lib/opal/connect/plugins/events.rb
+- lib/opal/connect/plugins/html.rb
+- lib/opal/connect/plugins/server.rb
+- lib/opal/connect/version.rb
+- opal-connect.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Connects Opal to Ruby.
+test_files: []