browserio 0.0.4 → 0.1.0

data/lib/browserio/component.rb

@@ -1,326 +0,0 @@
-module BrowserIO
-  class Component
-    include Methods
-
-    REJECTED_CLIENT_OPTS = %i(scope file_path methods_wrapped events klass on on_server_methods added_class_events)
-
-    class << self
-      # 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 args.any?
-
-        # 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
-          if obj.bio_opts.init.is_a? Array
-            obj.send :initialize, *obj.bio_opts.init, &block
-          else
-            obj.send :initialize, obj.bio_opts.init, &block
-          end
-        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, &blk|
-              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, &blk)
-              else
-                result = send(o_name, &blk)
-              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 = true)
-        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 server?
-            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 bio_on(*args, &block)
-        if args.first.to_s != 'server'
-          bio_opts.on << [args, block]
-        else
-          bio_on_server(&block)
-        end
-      end
-      alias_method :on, :bio_on
-
-      def method_missing(method, *args, &block)
-        if 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
-
-      def bio_on_server(&block)
-        if server?
-          yield
-        else
-          m = Module.new(&block)
-
-          m.public_instance_methods(false).each do |meth|
-            bio_opts.on_server_methods << meth.to_s
-
-            define_method "#{meth}" do |*args, &blk|
-              path_name = bio_opts.path_name
-              # event_id = "comp-event-#{$faye.generate_id}"
-
-              payload = client_bio_opts.reject do |k, _|
-                %w(html tmpl requires plugins object_events).include? k
-              end
-              payload[:method_called] = meth
-              payload[:method_args]   = args
-
-              HTTP.post("/#{bio_opts.assets_url}/#{path_name}.call",
-                headers: {
-                  'X-CSRF-TOKEN' => Element.find('meta[name=_csrf]').attr('content')
-                },
-                payload: payload) do |response|
-
-                  # We set the new csrf token
-                  xhr  = Native(response.xhr)
-                  csrf = xhr.getResponseHeader('BIO-CSRF-TOKEN')
-                  Element.find('meta[name=_csrf]').attr 'content', csrf
-                  ###########################
-
-                  res = JSON.from_object(`response`)
-
-                  blk.call res[:body], res
-              end
-
-              true
-            end
-          end
-
-          include m
-        end
-      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
-
-    if RUBY_ENGINE == 'opal'
-      def bio(*args)
-        BrowserIO[*args]
-      end
-    end
-
-    def method_missing(method, *args, &block)
-      if bio_opts.scope.respond_to?(method, true)
-        bio_opts.scope.send method, *args, &block
-      else
-        super
-      end
-    end
-  end
-end

data/lib/browserio/config.rb

@@ -1,120 +0,0 @@
-require 'ostruct'
-require 'browserio/events'
-
-module BrowserIO
-  class Config
-    include Methods
-
-    # Stores the options for the config
-    #
-    # @return [OpenStruct]
-    attr_accessor :opts
-
-    # Setup initial opts values
-    #
-    # @param opts [Hash] The initial params for #opts.
-    def initialize(opts = {})
-      opts = {
-        tmpl: IndifferentHash.new,
-        scope: false,
-        loaded: false,
-        requires: [],
-        on: [],
-        on_server_methods: [],
-        object_events: {},
-        is_plugin: false,
-        plugins: []
-      }.merge opts
-
-      @opts = OpenStruct.new(opts)
-    end
-
-    # Set the unique name of the component
-    #
-    # @param name [<String, Symbol>, #to_sym]
-    def name(name)
-      opts.name = name.to_sym
-      opts.is_plugin = true if name.to_s =~ /_plugin$/
-      BrowserIO.components ||= {}
-      BrowserIO.components[opts.name] = opts
-    end
-
-    def is_plugin?
-      opts.is_plugin
-    end
-
-    %w(scope assets_url).each do |m|
-      define_method m do |v|
-        opts[m] = v
-      end
-    end
-
-    # Used to set and update the dom
-    def dom
-      if server?
-        yield
-      end
-    end
-
-    # Set the raw html
-    # @param html [String]
-    def html(html)
-      unless RUBY_ENGINE == 'opal'
-        opts.html = begin
-          File.read html
-        rescue
-          html
-        end.strip
-      end
-    end
-
-    def requires(*args)
-      unless RUBY_ENGINE == 'opal'
-        args.each do |a|
-          if a.to_s[/_plugin$/]
-            require "browserio/plugins/#{a.to_s.gsub(/_plugin$/, '')}"
-          end
-          opts.requires << a
-        end
-      end
-    end
-
-    def opts_dup
-      opts.to_h.inject({}) {|copy, (key, value)| copy[key] = value.dup rescue value; copy}
-    end
-
-    def plugin(name)
-      unless RUBY_ENGINE == 'opal'
-        require "browserio/plugins/#{name}"
-      end
-    end
-
-    def get_requires(requires = false, previous_requires = [])
-      list = []
-
-      unless requires
-        requires ||= opts.requires.dup
-        previous_requires << opts.name.to_sym
-      end
-
-      previous_requires.each { |p| requires.delete(p) }
-
-      requires.each do |r|
-        klass = BrowserIO.components[r.to_sym].klass
-        o = klass.client_bio_opts.select do |k, v|
-          %w(path_name name assets_url requires).include? k.to_s
-        end
-
-        # We don't want to get a stack limit error so we stop something
-        # requiring itself
-        pr = previous_requires.dup << o[:name].to_sym
-
-        o[:requires] = get_requires o[:requires].dup, pr if o[:requires].present?
-
-        list << o
-      end
-
-      list
-    end
-  end
-end

data/lib/browserio/dom.rb

@@ -1,139 +0,0 @@
-module BrowserIO
-  class DOM
-    include Methods
-
-    attr_accessor :dom, :raw_html
-
-    class << self
-      # Shortcut for creating dom
-      # @param html [String]
-      # @return dom [DOM]
-      def [] html
-        new html
-      end
-    end
-
-    def initialize html
-      @raw_html = html
-
-      if server?
-        @dom = raw_html.is_a?(String) ? HTML[raw_html.dup] : raw_html
-      else
-        @dom = raw_html.is_a?(String) ? Element[raw_html.dup] : raw_html
-      end
-    end
-
-    def find string, &block
-      if client?
-        node = DOM.new dom.find(string)
-      elsif server?
-        if block_given?
-          node = DOM.new dom.css(string)
-        else
-          node = DOM.new dom.at(string)
-        end
-      end
-
-      if block_given?
-        node.each_with_index do |n, i|
-          block.call DOM.new(n), i
-        end
-      end
-
-      node
-    end
-
-    if RUBY_ENGINE == 'ruby'
-      def data key = false, value = false
-        d = Hash[node.xpath("@*[starts-with(name(), 'data-')]").map{|a| [a.name, a.value]}]
-
-        if !key
-          d
-        elsif key && !value
-          d[key]
-        else
-          node["data-#{key}"] = value
-        end
-      end
-
-      def val value
-        node.content = value
-      end
-
-      def add_class classes
-        classes = (classes || '').split ' ' unless classes.is_a? Array
-        new_classes =  ((node.attr('class') || '').split(' ') << classes).uniq.join(' ')
-        node['class'] = new_classes
-      end
-
-      def remove_class classes
-        classes = (classes || '').split ' ' unless classes.is_a? Array
-        (node.attr('class') || '').split(' ').reject { |n| n =~ /active|asc|desc/i }.join(' ')
-      end
-
-      def attr key, value = false
-        if value
-          value = value.join ' ' if value.is_a? Array
-          node[key] = value
-        else
-          super key
-        end
-      end
-    end
-
-    def html= content
-      if server?
-        node.inner_html = content
-      else
-        content = content.dom if content.is_a? BrowserIO::DOM
-        node.html content
-      end
-
-      node
-    end
-
-    if RUBY_ENGINE == 'opal'
-      # make it supply the jquery element so it will use that as it doesn't
-      # know how to handle the DOM element.
-      %w(append prepend replace_with after before).each do |meth|
-        define_method meth do |obj|
-          obj = obj.dom if obj.is_a? BrowserIO::DOM
-          super obj
-        end
-      end
-
-      def to_html
-        @dom ||= DOM.new '<div>'
-        el = dom.first
-        DOM.new('<div>').append(el).html
-      end
-    end
-
-    def html content = false
-      if !content
-        if server?
-          node.inner_html
-        else
-          node ? node.html : dom.html
-        end
-      else
-        self.html = content
-      end
-    end
-
-    def node
-      @node || dom
-    end
-
-    # This allows you to use all the nokogiri or opal jquery methods if a
-    # global one isn't set
-    def method_missing method, *args, &block
-      # respond_to?(symbol, include_all=false)
-      if dom.respond_to? method, true
-        dom.send method, *args, &block
-      else
-        super
-      end
-    end
-  end
-end