browserio 0.0.1 → 0.0.2

data/lib/browserio/config.rb

@@ -0,0 +1,113 @@
+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: [],
+        object_events: {},
+        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
+      BrowserIO.components ||= {}
+      BrowserIO.components[opts.name] = opts
+    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

@@ -0,0 +1,139 @@
+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

data/lib/browserio/events.rb

@@ -0,0 +1,136 @@
+module BrowserIO
+  class Events
+    attr_accessor :scope, :browser_events, :object_events
+
+    VIP_ORDER_LIST = %w(history_change)
+
+    def initialize
+      @browser_events = []
+      @object_events  = {}
+    end
+
+    def add(*args, &block)
+      event = {
+        name: args.shift,
+        block: block,
+        options: {}
+      }
+
+      args.each do |arg|
+        if arg.is_a?(String)
+          event[:selector] = arg
+        elsif arg.is_a? Class
+          event[:klass] = arg
+        else
+          event[:options] = event[:options].merge(arg).indifferent.to_h
+        end
+      end
+
+      if event[:name].to_s == 'ready' || event[:name] =~ /[:\s]/ || event[:selector]
+        browser_events << event
+      else
+        event[:component] = scope.bio_opts.name
+
+        if !scope.class.bio_opts.added_class_events && for_component = event[:options].delete(:for)
+          bio_opts = BrowserIO.components[for_component].klass.bio_opts
+          events = bio_opts.object_events[event.delete(:name)] ||= []
+          events << event
+        else
+          events = object_events[event.delete(:name)] ||= []
+          events << event
+        end
+      end
+    end
+
+    def trigger(name, options = {})
+      name    = name.to_s
+      options = options.indifferent
+
+      case name
+      when 'browser_events'
+        # We make sure anything in the VIP_ORDER_LIST goes first
+        (browser_events.sort_by do |x|
+          [VIP_ORDER_LIST.index(x[:name]) || VIP_ORDER_LIST.length, browser_events.index(x)]
+        end).each do |event|
+          trigger_browser_event event
+        end
+      else
+        events = object_events[name] || []
+        events.each do |event|
+          BrowserIO[event[:component]].instance_exec options, &event[:block]
+        end
+      end
+    end
+
+    def trigger_browser_event event
+      comp = BrowserIO[scope.bio_opts.name]
+
+      case event[:name]
+      when 'ready'
+        el = Element.find(event[:selector] != '' ? event[:selector] : 'body')
+
+        comp.instance_exec el, &event[:block]
+      when 'history_change'
+        $window.history.change do |he|
+          comp.instance_exec he, &event[:block]
+        end
+      when 'form'
+        warn 'missing form class option' unless event[:klass]
+
+        Document.on :submit, event[:selector] do |evt|
+          el = evt.current_target
+          evt.prevent_default
+
+          params = {}
+
+          # loop through all the forum values
+          el.serialize_array.each do |row|
+            field, _ = row
+
+            # we need to make it native to access it like ruby
+            field    = Native(field)
+            name     = field['name']
+            value    = field['value']
+
+            params[name] = value
+          end
+
+          params_obj = {}
+
+          params.each do |param, value|
+            keys = param.gsub(/[^a-z0-9_]/, '|').gsub(/\|\|/, '|').gsub(/\|$/, '').split('|')
+            params_obj = params_obj.deep_merge keys.reverse.inject(value) { |a, n| { n => a } }
+          end
+
+          opts[:dom] = el
+
+          if opts && key = opts[:key]
+            form = event[:klass].new params_obj[key], opts
+          else
+            form = event[:klass].new params_obj, opts
+          end
+
+          el.find(opts[:error_selector] || '.field-error').remove
+
+          comp.instance_exec form, evt.current_target, evt, &event[:block]
+        end
+      else
+        args = [event[:name]]
+
+        if selector = event[:selector]
+          args << selector
+        end
+
+        Document.on(*args) do |evt|
+          el = evt.current_target
+          comp.instance_exec el, evt, &event[:block]
+        end
+
+        if event[:name] =~ /ready/
+          el = Element.find(event[:selector] != '' ? event[:selector] : 'body')
+          comp.instance_exec el, &event[:block]
+        end
+      end
+    end
+  end
+end

data/lib/browserio/html.rb

@@ -0,0 +1,29 @@
+module BrowserIO
+  module HTML
+    include Methods
+
+    class << self
+      # Parse HTML into a Nokogiri object
+      # @param raw_html [String]
+      # @return parsed_html [Nokogiri]
+      def [](raw_html)
+        return unless server?
+
+        # remove all the starting and trailing whitespace
+        raw_html = raw_html.strip
+
+        if raw_html[/\A<!DOCTYPE/] || raw_html[/\A<html/]
+          Nokogiri::HTML(raw_html)
+        else
+          parsed_html = Nokogiri::HTML.fragment(raw_html)
+
+          if parsed_html.children.length >= 1
+            parsed_html.children.first
+          else
+            parsed_html
+          end
+        end
+      end
+    end
+  end
+end

data/lib/browserio/opal.rb

@@ -0,0 +1,18 @@
+require 'opal'
+require 'opal-jquery'
+
+if RUBY_ENGINE == 'ruby'
+  module Opal
+    class Builder
+      # @return [String] Compiled javascript.
+      def javascript
+        to_s
+      end
+    end
+  end
+end
+
+module BrowserIO
+  # Create our own opal instance.
+  Opal = ::Opal.dup
+end

data/lib/browserio/plugins/form.rb

@@ -0,0 +1,343 @@
+require 'browserio/plugins/validations'
+require 'forwardable'
+
+module BrowserIO
+  module Plugins
+    class Form < Component
+      config.name :form_plugin
+
+      include Methods
+      include Validations
+
+      module Delegates
+        def _delegates(*names)
+          accessors = Module.new do
+            extend Forwardable # DISCUSS: do we really need Forwardable here?
+            names.each do |name|
+              delegate [name, "#{name}="] => :_attributes
+            end
+          end
+          include accessors
+        end
+      end
+
+      extend Delegates
+
+      class Attributes
+        def set_values(atts)
+          @_attributes = []
+
+          atts.each do |key, val|
+            if respond_to?("#{key}=")
+              send(:"#{key}=", val)
+              @_attributes << key
+            end
+          end
+        end
+
+        def set_attr_accessors attrs
+          attrs.each do |attr|
+            define_singleton_method "#{attr}=" do |value|
+              value = value.to_obj if value.is_a? Hash
+              instance_variable_set(:"@#{attr}", value)
+              @_attributes ||= []
+              @_attributes << attr
+            end
+
+            define_singleton_method attr do
+              instance_variable_get(:"@#{attr}")
+            end
+          end
+        end
+
+        def _attributes
+          @_attributes ||= []
+        end
+
+        def empty?
+          _attributes.empty?
+        end
+      end
+
+      # Initialize with a hash of attributes and values.
+      # If extra attributes are sent, a NoMethodError exception will be raised.
+      #
+      # @example
+      #
+      #   class EditPost < Scrivener
+      #     attr_accessor :title
+      #     attr_accessor :body
+      #
+      #     def validate
+      #       assert_present :title
+      #       assert_present :body
+      #     end
+      #   end
+      #
+      #   edit = EditPost.new(title: "Software Tools")
+      #
+      #   edit.valid? #=> false
+      #
+      #   edit.errors[:title] #=> []
+      #   edit.errors[:body]  #=> [:not_present]
+      #
+      #   edit.body = "Recommended reading..."
+      #
+      #   edit.valid? #=> true
+      #
+      #   # Now it's safe to initialize the model.
+      #   post = Post.new(edit.attributes)
+      #   post.save
+      def initialize(atts = {}, options = {})
+        @_data    = atts
+        @_data    = atts.to_obj if atts.is_a? Hash
+        @_options = options
+
+        # @_attributes = Class.new(Attributes).new
+        @_attributes = Attributes.new
+        @_attributes.set_attr_accessors _attr_accessors
+        @_attributes.set_values _data
+
+        _data.each do |key, val|
+          send("#{key}=", val)
+        end
+
+        _form.each do |key, klass|
+          opts = {}
+          opts[key] = klass.new(_data.send(key)) if _data.respond_to?(key)
+          @_attributes.set_values opts
+
+          send("#{key}=", opts[key])
+        end
+      end
+
+      def self.attr_accessor(*vars)
+        @_attr_accessors ||= []
+        @_form ||= {}
+
+        vars.each do |v|
+          if !v.is_a? Hash
+            @_attr_accessors << v unless @_attr_accessors.include? v
+          else
+            v = v.first
+
+            unless @_attr_accessors.include? v.first
+              @_attr_accessors << v.first
+              @_form[v.first] = v.last
+            end
+          end
+        end
+
+        _delegates(*_attr_accessors)
+      end
+
+      def method_missing method, *args, &block
+        # respond_to?(symbol, include_all=false)
+        if _data.respond_to? method, true
+          _data.send method, *args, &block
+        else
+          return if method[/\=\z/]
+
+          super
+        end
+      end
+
+      # Return hash of attributes and values.
+      def attributes
+        Hash.new.tap do |atts|
+          _attributes.instance_variables.each do |ivar|
+            # todo: figure out why it's setting @constructor and @toString
+            next if ivar == :@constructor || ivar == :@toString || ivar == :@_attributes || ivar == :@_data || ivar == :@_forms
+
+            att = ivar[1..-1].to_sym
+            atts[att] = _attributes.send(att)
+
+            if klass = _form[att.to_s.to_sym]
+              atts[att] = klass.new(atts[att]).attributes
+            end
+          end
+        end
+      end
+
+      def model_attributes data = attributes
+        hash = {}
+
+        data.each do |k, v|
+          if klass = _form[k.to_s.to_sym]
+            d = data[k]
+            d = d.attributes if d.is_a?(Form)
+
+            f  = klass.new d
+            k  = "#{k}_attributes"
+            dt = f.model_attributes
+
+            hash[k] = model_attributes dt
+          elsif v.is_a? Hash
+            hash[k] = model_attributes data[k]
+          else
+            hash[k] = v
+          end
+        end
+
+        hash
+      end
+
+      def slice(*keys)
+        Hash.new.tap do |atts|
+          keys.each do |att|
+            atts[att] = send(att)
+            # atts[att] = _attributes.send(att)
+          end
+        end
+      end
+
+      def display_errors options = {}, &block
+        dom = options.delete(:dom) || _dom
+        d_errors = errors
+
+        if override_errors = options[:override_errors]
+          d_errors = override_errors
+        end
+
+        keys = options.delete(:keys) || (_options[:key] ? [_options[:key]] : [])
+
+        if extra_errors = options.delete(:errors)
+          extra_errors.each do |key, value|
+            d_errors[key] = value
+          end
+        end
+
+        d_errors.each do |key, error|
+          d_keys = (keys.dup << key)
+
+          error = error.first
+
+          if error.is_a?(Hash)
+            d_options = options.dup
+            d_options[:keys] = d_keys
+            d_options[:override_errors] = d_errors[key].first
+
+            display_errors d_options, &block
+          elsif !block_given? || block.call(d_keys, error) == false
+            name = d_keys.each_with_index.map do |field, i|
+              i != 0 ? "[#{field}]" : field
+            end.join
+
+            if tmpl = options[:tmpl]
+              if client?
+                field_error_dom = DOM.new(`#{tmpl.dom}[0].outerHTML`)
+              else
+                field_error_dom = DOM.new(tmpl.dom.to_html)
+              end
+            else
+              field_error_dom = DOM.new('<span class="field-error"><span>')
+            end
+
+            field_error_dom.html _error_name(key, error)
+
+            field = dom.find("[name='#{name}']")
+            field.before field_error_dom.dom
+          end
+        end
+      end
+      alias_method :render_errors, :display_errors
+
+      def render_values dom = false, key = false, data = false
+        dom = _options[:dom] unless dom
+        key = _options[:key] if !key && _options.key?(:key)
+
+        dom.find('input, select, textarea') do |element|
+          name  = element['name']
+          name  = name.gsub(/\A#{key}/, '') if key
+          keys  = name.gsub(/\A\[/, '').gsub(/[^a-z0-9_]/, '|').gsub(/\|\|/, '|').gsub(/\|$/, '').split('|')
+          value = false
+
+          keys.each do |k|
+            begin
+              value = value ? value.send(k) : send(k)
+            rescue
+              value = ''
+            end
+          end
+
+          case element.name
+          when 'select'
+            element.find('option') do |x|
+              x['selected'] = true if x['value'] == value.to_s
+            end
+          when 'input'
+            if %w(radio checkbox).include? element['type']
+              if element['value'] == value.to_s
+                element['checked'] = true
+              else
+                element.delete 'checked'
+              end
+            else
+              value = sprintf('%.2f', value) if value.is_a? BigDecimal
+              element['value'] = value.to_s
+            end
+          when 'textarea'
+            element.val value.to_s
+          end
+        end
+      end
+
+      def _attributes
+        @_attributes ||= {}
+      end
+
+      def validate_msg error, column
+        false
+      end
+
+      protected
+
+      def _data
+        @_data ||= {}
+      end
+
+      def self._attr_accessors
+        @_attr_accessors ||= []
+      end
+
+      def self._form
+        @_form || {}
+      end
+
+      def _form
+        self.class._form
+      end
+
+      def _attr_accessors
+        self.class._attr_accessors
+      end
+
+      def _options
+        @_options
+      end
+
+      def _dom
+        @_dom ||= @_options[:dom]
+      end
+
+      def _error_name key, error
+        validate_msg(error.to_sym, key.to_sym) || case error.to_s.to_sym
+        when :not_email
+          'Email Isn\'t Valid.'
+        when :not_present
+          'Required.'
+        when :not_equal
+          'Password does not match.'
+        else
+          !error[/\s/] ? error.to_s.gsub(/_/, ' ').titleize : error
+        end
+      end
+
+      def empty?
+        _attributes.empty?
+      end
+    end
+  end
+end
+
+BrowserIO::Form = BrowserIO::Plugins::Form