browserio 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 405d7d3fe522f2989d67f63534a454860f8e6510
-  data.tar.gz: d1a294cb773fa702087f0fb0a11b9977dc9fe345
+  metadata.gz: 48125d1757fc1b32e8551a1f303debbd8091a1bf
+  data.tar.gz: ef4f1f24a520017fc29568b731bce9741fe1ff70
 SHA512:
-  metadata.gz: f112750279ff5234ef7ba65746fc00d8eb25e84c96b11e5c40e9d65dff1d047da5e5246a6de45b6fb88edd8f8ef9f10044429dce8edf6d8d5609719f457b1d4d
-  data.tar.gz: be5f11303c2f9259f3ccc7c5372dd71aa0765418699c855d130ebc810e182bbf9cfd42967464c22d38372f351f3e34c545183521f84a7044339a3fc4a97fe63b
+  metadata.gz: 52f519118b696c1d83d4645261ef1f1166082a728ace2563271f4d1f4a1fb8380f7e0e9be8a3a5856b87ac57028c37debf525d33708d66d824acc44aed3085e8
+  data.tar.gz: 158724dbc60016ef7c4f21704e748a0c1c994476cab072847bdb98e4d6776beb3914252b7fd07419e898b3b3790b8a2faaa90d2a2f8163975adc095a515ffb34

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in BrowserIO.gemspec
 gemspec
+
+gem 'opal', github: 'opal/opal'

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 cj
+Copyright (c) 2015 cj
 
 MIT License
 

data/README.md

@@ -1,13 +1,13 @@
 # BrowserIO
 
-TODO: Write a gem description
+Components for Ruby.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'BrowserIO'
+gem 'browserio'
 ```
 
 And then execute:
@@ -16,11 +16,29 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install BrowserIO
+    $ gem install browserio
 
-## Usage
+## Basic Usage
 
-TODO: Write usage instructions here
+### Setup
+
+    class BasicComponent < BrowserIO::Component
+      setup do |config|
+        config.name :basic
+      end
+
+      def foo
+        'bar'
+      end
+    end
+
+### Call
+
+    Browser[:basic].foo
+
+### Response
+
+    'bar'
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,9 @@
-require "bundler/gem_tasks"
+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/browserio.gemspec

@@ -1,15 +1,15 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'browserio'
+require 'browserio/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "browserio"
   spec.version       = BrowserIO::VERSION
   spec.authors       = ["cj"]
   spec.email         = ["cjlazell@gmail.com"]
-  spec.summary       = %q{}
-  spec.description   = %q{}
+  spec.summary       = %q{Components for the Browser and Server}
+  spec.description   = %q{Components for the Browser and Server}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -18,7 +18,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "roda"
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency "opal", "~> 0.7.1"
+  spec.add_runtime_dependency "opal-jquery", "~> 0.3.0"
+  spec.add_runtime_dependency "nokogiri", '~> 1.6.6.2'
+
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "phantomjs.rb"
+  spec.add_development_dependency 'minitest-line'
+  spec.add_development_dependency 'minitest-reporters'
+  spec.add_development_dependency 'roda'
 end

data/lib/browserio.rb

@@ -1,5 +1,185 @@
-require "roda"
+require 'browserio/opal'
+require 'browserio/version'
+require 'browserio/utilis/indifferent_hash'
+require 'browserio/utilis/hash'
+require 'browserio/utilis/blank'
+require 'browserio/utilis/methods'
+require 'browserio/utilis/try'
+require 'browserio/utilis/titleize'
+require 'base64'
+require 'nokogiri' unless RUBY_ENGINE == 'opal'
+require 'browserio/html'
+require 'browserio/dom'
+require 'browserio/config'
+require 'browserio/component'
 
-class BrowserIO < Roda
-  VERSION = "0.0.1"
+module BrowserIO
+  include Methods
+
+  class << self
+    # Used to call a component.
+    #
+    # @example
+    #   Browser[:foo].bar
+    #
+    # @param name [String, Symbol, #to_s] The unique name given to a component.
+    # @return [BrowserIO::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
+
+    if RUBY_ENGINE == 'ruby'
+      # Returns the build object for opal.
+      #
+      # @param path [String] require path to file to build.
+      # @return [String, Opal::Builder#build]
+      def build(path = 'browserio', options = {})
+        append_paths
+        Opal::Builder.build(path, options)
+      end
+
+      # Source maps for the javascript
+      def source_map(path = 'browserio', 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('/browserio.rb', '')
+          BrowserIO::Opal.append_path file
+          BrowserIO::Opal.append_path Dir.pwd
+        end
+      end
+    end
+
+    # Return the opal javascript.
+    def javascript(name = 'browserio', options = {}, promise = false)
+      if server?
+        if name == 'browserio'
+          @bio_javascript ||= build(name, options).javascript
+        else
+          js = build(name, options).javascript
+          comp_name = components.to_h.select { |k, v| v.path_name == name }.first.last.name
+          comp = BrowserIO[comp_name]
+          options = comp.client_bio_opts
+          compiled_opts = Base64.encode64 options.to_json
+          js << Opal.compile("BrowserIO.components[:#{comp_name}].klass.instance_variable_set(:@bio_config, BrowserIO::Config.new(BrowserIO.components[:#{comp_name}].klass.bio_config.opts_dup.merge(JSON.parse(Base64.decode64('#{compiled_opts}')))))")
+          js
+        end
+      else
+        opts.loaded ||= {}
+
+        if !opts.loaded.keys.include? name
+          opts.loaded[name] = false
+
+          assets_url = options[:assets_url]
+
+          `$.getScript("/" + assets_url + "/" + name + ".js").done(function(){`
+            BrowserIO.opts.loaded[name] = true
+            method_called = options.delete(:method_called)
+            method_args   = options.delete(:method_args)
+            name          = options.delete(:name)
+            comp          = BrowserIO[name, options]
+            requires      = comp.bio_opts.requires
+
+            if requires.present? && requires.first.is_a?(Hash)
+              comps = []
+
+              ::Opal::Promise.when(*get_requires(requires, comps)).then do
+                comp.send(method_called, *method_args) if method_called
+                comp.bio_trigger :browser_events
+              end
+            else
+              comp.send(method_called, *method_args) if method_called
+              comp.bio_trigger :browser_events
+            end
+
+            promise.resolve true if promise
+          `}).fail(function(jqxhr, settings, exception){ window.console.log(exception); });`
+        end
+      end
+    end
+
+    def get_requires requires, reqs = [], from_get = false
+      promises = []
+
+      requires.each do |r|
+        if r[:requires].any?
+          promises << (promise = ::Opal::Promise.new)
+
+          a = []
+          c = []
+
+          get_requires(r[:requires], a, true)
+
+          a.each do |re|
+            c << -> do
+              p = ::Opal::Promise.new
+
+              path_name = re.delete(:path_name)
+              BrowserIO.javascript(path_name, re.reject { |k, v| k.to_s == 'requires'}, p)
+
+              p
+            end
+          end
+
+          ::Opal::Promise.when(*c.map!(&:call)).then do |*args|
+            path_name = r.delete(:path_name)
+            BrowserIO.javascript(path_name, r.reject { |k, v| k.to_s == 'requires'}, promise)
+          end
+        else
+          reqs << r
+
+          if !from_get
+            promises << (promise = ::Opal::Promise.new)
+
+            path_name = r.delete(:path_name)
+            BrowserIO.javascript(path_name, r.reject { |k, v| k.to_s == 'requires'}, promise)
+          end
+        end
+      end
+
+      promises
+    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)
+      javascript # This pre-compiles the core and store it in mem
+      block.call config
+    end
+
+    def config
+      @config ||= begin
+        args = { klass: self }
+
+        if RUBY_ENGINE == 'ruby'
+          args[:file_path] = caller.first.gsub(/(?<=\.rb):.*/, '')
+        end
+
+        Config.new(args)
+      end
+    end
+    alias_method :config, :config
+
+    def opts
+      config.opts
+    end
+  end
 end

data/lib/browserio/component.rb

@@ -0,0 +1,269 @@
+module BrowserIO
+  class Component
+    include Methods
+
+    REJECTED_CLIENT_OPTS = %i(scope file_path methods_wrapped events klass on added_class_events)
+
+    class << self
+      alias_method :__new__, :new
+
+      # Override the default new behaviour
+      def new(*args, &block)
+        obj = allocate
+
+        obj.bio_opts.js   = args.delete(:js)
+        obj.bio_opts.init = args.delete(:init)
+
+        # Merge other args into opts
+        args.each { |a| a.each {|k, v| obj.bio_opts[k] = v } } if client?
+
+        # Set all the requires
+        unless RUBY_ENGINE == 'opal'
+          obj.bio_opts.requires = obj.bio_config.get_requires
+        end
+
+        obj.bio_opts.events.scope = obj
+
+        # Set all the on events
+        obj.bio_opts.on.each do |*a, &b|
+          obj.bio_opts.events.add(*a.first.first, &a.first.last)
+        end
+        bio_opts.added_class_events = true
+
+        if obj.bio_opts.init && obj.method(:initialize).parameters.length > 0
+          obj.send :initialize, *obj.bio_opts.init, &block
+        else
+          obj.send :initialize, &block
+        end
+
+        unless bio_opts.methods_wrapped
+          obj.bio_opts.methods_wrapped = bio_opts.methods_wrapped = true
+
+          public_instance_methods(false).each do |meth|
+            alias_method :"bio_original_#{meth}", :"#{meth}"
+            define_method "#{meth}" do |*d_args|
+              if bio_opts.js
+                bio_opts.method_called = meth
+                bio_opts.method_args   = *d_args
+              end
+
+              o_name = "bio_original_#{meth}"
+
+              if client? || method(o_name).parameters.length > 0
+                result = send(o_name, *d_args, &block)
+              else
+                result = send(o_name, &block)
+              end
+
+              # Append the initialize javscript
+              if server? && opts.js
+                result = result.to_html if result.is_a? DOM
+                result << bio_javascript
+              end
+
+              result
+            end
+          end
+        end
+
+        obj
+      end
+
+      # Used to setup the component with default options.
+      #
+      # @example
+      #   class SomeComponent < Component
+      #     setup do |config|
+      #       config.name :some
+      #     end
+      #   end
+      # @yield [Config]
+      def bio_setup(&block)
+        block.call bio_config
+      end
+      alias_method :setup, :bio_setup
+
+      # Set templates
+      #
+      # @example
+      #   tmpl :some_name, dom.find('#some-div')
+      # @return dom [DOM]
+      def bio_tmpl(name, dom = false, remove = false)
+        if dom
+          dom = remove ? dom.remove : dom
+          bio_opts.tmpl[name] = {
+            dom:  dom,
+            html: dom.to_html
+          }
+        elsif t = bio_opts.tmpl[name]
+          dom = DOM.new t[:html]
+        else
+          false
+        end
+
+        dom
+      end
+      alias_method :tmpl, :bio_tmpl
+
+      def bio_dom
+        @bio_dom ||= DOM.new bio_opts.html
+      end
+      alias_method :dom, :bio_dom
+
+      # Shortcut for BrowserIO.components
+      #
+      # @return [Hash, BrowserIO.components]
+      def bio_components
+        BrowserIO.components ||= {}
+      end
+      alias_method :components, :bio_components
+
+      # Shortcut for the Config#opts
+      #
+      # @return [Openstruct, Config#opts]
+      def bio_opts
+        bio_config.opts
+      end
+      alias_method :opts, :bio_opts
+
+      def bio_config
+        @bio_config ||= begin
+          args = BrowserIO.config.opts_dup.merge(klass: self, object_events: {})
+
+          if RUBY_ENGINE == 'ruby'
+            args[:file_path] = caller.first.gsub(/(?<=\.rb):.*/, '')
+            args[:path_name] = args[:file_path]
+              .gsub(%r{(#{Dir.pwd}/|.*(?=browserio))}, '')
+              .gsub(/\.rb$/, '')
+          end
+
+          c = Config.new(args)
+
+          # If extending from a plugin it will automatically require it.
+          ancestors.each do |klass|
+            next if klass.to_s == name.to_s
+
+            if klass.method_defined?(:bio_opts) && klass.bio_opts.name.to_s =~ /_plugin$/
+              c.requires klass.bio_opts.name
+            end
+          end
+
+          c
+        end
+      end
+      alias_method :config, :bio_config
+
+      def on(*args, &block)
+        bio_opts.on << [args, block]
+      end
+
+      def method_missing(method, *args, &block)
+        if server? && bio_opts.scope.respond_to?(method, true)
+          bio_opts.scope.send method, *args, &block
+        else
+          super
+        end
+      end
+
+      def client_bio_opts
+        bio_config.opts_dup.reject {|k, v| REJECTED_CLIENT_OPTS.include? k }
+      end
+    end
+
+    # Duplicate of class condig [Config]
+    # @return config [Config]
+    def bio_config
+      @bio_config ||= begin
+        c = Config.new(self.class.bio_config.opts_dup.merge(events: Events.new))
+        c.opts.events.object_events = c.opts.object_events.dup
+        c.opts.object_events = {}
+        c
+      end
+    end
+    alias_method :config, :bio_config
+
+    # Duplicated of config.opts [Config#opts]
+    # @return opts [Config#opts]
+    def bio_opts
+      bio_config.opts
+    end
+    alias_method :opts, :bio_opts
+
+    # Grab a copy of the template
+    # @return dom [DOM]
+    def bio_tmpl(name)
+      self.class.bio_tmpl name
+    end
+    alias_method :tmpl, :bio_tmpl
+
+    # Dom
+    # @return bio_dom [Dom]
+    def bio_dom
+      @bio_dom ||= begin
+        if server?
+          DOM.new self.class.bio_dom.to_html
+        else
+          DOM.new(Element)
+        end
+      end
+    end
+    alias_method :dom, :bio_dom
+
+    # Special method that acts like the javascript equivalent
+    # @example
+    #   foo = {
+    #     bar: function { |moo|
+    #       moo.call 'something'
+    #     }
+    #   }.to_n
+    def bio_function(*args, &block)
+      args.any? && raise(ArgumentError, '`function` does not accept arguments')
+      block || raise(ArgumentError, 'block required')
+      proc do |*a|
+        a.map! {|x| Native(`x`)}
+        @this = Native(`this`)
+        %x{
+         var bs = block.$$s,
+            result;
+          block.$$s = null;
+          result = block.apply(self, a);
+          block.$$s = bs;
+          
+          return result;
+        }
+      end
+    end
+    alias_method :function, :bio_function
+
+    def bio_javascript
+      return unless server?
+
+      compiled_opts = Base64.encode64 client_bio_opts.to_json
+      name          = bio_opts.file_path.gsub("#{Dir.pwd}/", '').gsub(/\.rb$/, '')
+
+      javascript = <<-JS
+        BrowserIO.javascript('#{name}', JSON.parse(Base64.decode64('#{compiled_opts}')))
+      JS
+      "<script>#{Opal.compile(javascript)}</script>"
+    end
+    alias_method :javscript, :bio_javascript
+
+    def client_bio_opts
+      bio_config.opts_dup.reject {|k, v| REJECTED_CLIENT_OPTS.include? k }
+    end
+    alias_method :client_opts, :client_bio_opts
+
+    def bio_trigger *args
+      bio_opts.events.trigger *args
+    end
+    alias_method :trigger, :bio_trigger
+
+    def method_missing(method, *args, &block)
+      if server? && bio_opts.scope.respond_to?(method, true)
+        bio_opts.scope.send method, *args, &block
+      else
+        super
+      end
+    end
+  end
+end