browserio 0.0.4 → 0.1.0

data/lib/browserio/plugins/history.rb

@@ -1,92 +0,0 @@
-module BrowserIO
-  module Plugins
-    class History < Component
-      config.name :history_plugin
-    end
-  end
-end
-
-if RUBY_ENGINE == 'opal'
-  require 'browserio/plugins/location'
-
-  module Browser
-    # {Window} instances are {Native} objects used to wrap native window instances.
-    #
-    # Generally, you will want to use the top level {::Window} instance, which
-    # wraps `window` from the main page.
-    class Window
-      include Native
-
-      # @!attribute [r] history
-      # @return [History] the history for this window
-      def history
-        History.new(`#@native.history`) if `#@native.history`
-      end
-    end
-
-    # {History} allows manipulation of the session history.
-    #
-    # @see https://developer.mozilla.org/en-US/docs/Web/API/History
-    class History
-      include Native
-
-      # @!attribute [r] length
-      # @return [Integer] how many items are in the history
-      alias_native :length
-
-      # Go back in the history.
-      #
-      # @param number [Integer] how many items to go back
-      def back(number = 1)
-        `History.go(-number)`
-      end
-
-      # Go forward in the history.
-      #
-      # @param number [Integer] how many items to go forward
-      def forward(number = 1)
-        `History.go(number)`
-      end
-
-      # Push an item in the history.
-      #
-      # @param item [String] the item to push in the history
-      # @param data [Object] additional state to push
-      def push(item, data = nil)
-        data = `null` if data.nil?
-
-        `History.pushState(jQuery.parseJSON(data.$to_json()), null, item)`
-      end
-
-      # Replace the current history item with another.
-      #
-      # @param item [String] the item to replace with
-      # @param data [Object] additional state to replace
-      def replace(item, data = nil)
-        data = `null` if data.nil?
-
-        `History.replaceState(data, null, item)`
-      end
-
-      def get_state
-        Native(`History.getState()`)
-      end
-
-      # @!attribute [r] current
-      # @return [String] the current item
-      def current
-        $window.location.path
-      end
-
-      def change &block
-        %x{
-          History.Adapter.bind(window,'statechange',function(e){
-            var state = History.getState();
-            state = #{Native(`state`)}
-            return #{block.call(`state`)}
-          });
-        }
-      end
-    end
-  end
-end

data/lib/browserio/plugins/location.rb

@@ -1,78 +0,0 @@
-module Browser
-
-  # Allows manipulation of a location, usually from {Window} and {DOM::Document}.
-  #
-  # @see https://developer.mozilla.org/en-US/docs/Web/API/Location
-  class Location
-    include Native
-
-    # Change the location.
-    #
-    # @param url [String, #to_s] the URL to go to
-    def assign(url)
-      `#@native.assign(#{url.to_s})`
-    end
-
-    # Replace the current URL.
-    #
-    # @param url [String, #to_s] the URL to go to
-    def replace(url)
-      `#@native.replace(#{url.to_s})`
-    end
-
-    # Reload the page.
-    #
-    # @param force [Boolean] whether to force the reload
-    def reload(force = false)
-      `#@native.reload(force)`
-    end
-
-    # Convert the location to a string.
-    def to_s
-      `#@native.toString()`
-    end
-
-    # @!attribute fragment
-    # @return [String] the hash fragment of the location URI
-    alias_native :fragment, :hash
-    alias_native :fragment=, :hash=
-
-    # @!attribute host
-    # @return [String] the host part of the location URI
-    alias_native :host
-    alias_native :host=
-
-    # @!attribute uri
-    # @return [String] the whole location URI
-    alias_native :uri, :href
-    alias_native :uri=, :href=
-
-    # @!attribute path
-    # @return [String] the path part of the location URI
-    alias_native :path, :pathname
-    alias_native :path=, :pathname=
-
-    # @!attribute port
-    # @return [Integer] the port part of the location URI
-    alias_native :port
-    alias_native :port=
-
-    # @!attribute scheme
-    # @return [String] the scheme part of the location URI
-    alias_native :scheme, :protocol
-    alias_native :scheme=, :protocol=
-
-    # @!attribute query
-    # @return [String] the query part of the location URI
-    alias_native :query, :search
-    alias_native :query=, :search=
-  end
-
-  class Window
-    # @!attribute [r] location
-    # @return [Location] the location for the window
-    def location
-      Location.new(`#@native.location`) if `#@native.location`
-    end
-  end
-end

data/lib/browserio/plugins/pjax.rb

@@ -1,65 +0,0 @@
-module BrowserIO
-  module Plugins
-    class Pjax < Component
-      config.name :pjax_plugin
-      config.requires :history_plugin
-
-      class Nanobar
-        include Native
-
-        alias_native :go
-        alias_native :start
-        alias_native :finish
-
-        def initialize options = {}
-          `var Nanobar=function(){"use strict";var t,i,e,s,h,n,o={width:"100%",height:"4px",zIndex:9999,top:"0"},a={width:0,height:"100%",clear:"both",transition:"height .3s"};return t=function(t,i){var e;for(e in i)t.style[e]=i[e];t.style["float"]="left"},s=function(){var t=this,i=this.width-this.here;.1>i&&i>-.1?(h.call(this,this.here),this.moving=!1,100==this.width&&(this.el.style.height=0,setTimeout(function(){t.cont.el.removeChild(t.el)},300))):(h.call(this,this.width-i/4),setTimeout(function(){t.go()},16))},h=function(t){this.width=t,this.el.style.width=this.width+"%"},n=function(){var t=new i(this);this.bars.unshift(t)},i=function(i){this.el=document.createElement("div"),this.el.style.backgroundColor=i.opts.bg,this.width=0,this.here=0,this.moving=!1,this.cont=i,t(this.el,a),i.el.appendChild(this.el)},i.prototype.go=function(t){t?(this.here=t,this.moving||(this.moving=!0,s.call(this))):this.moving&&s.call(this)},e=function(i){var e,s,h=this.opts=i||{};h.bg=h.bg||"#000",this.bars=[],e=this.el=document.createElement("div"),t(this.el,o),h.id&&(e.id=h.id),h.className&&(e.className=h.className),e.style.position=h.target?"relative":"fixed",h.target?(s=h.target,s.insertBefore(e,h.target.firstChild)):(s=document.getElementsByTagName("body")[0],s.appendChild(e)),s.className="nanobar-custom-parent",n.call(this)},e.prototype.go=function(t){this.bars[0].go(t),100==t&&n.call(this)},e.prototype.start=function(){(function(){var t=this.bars[0],i=function(){setTimeout(function(){var e=t.here+Math.round(10*Math.random());t.here>=99||(e>99&&(e=99),t.go(e),i())},500)};t.go(10),i()}).call(this)},e.prototype.finish=function(){this.go(100)},e}();`
-          super `new Nanobar(options)`
-        end
-      end if client?
-
-      def progress_bar
-        $pjax_progress_bar
-      end
-
-      def get href = false
-        $pjax_progress_bar = Nanobar.new({bg: '#f99f22'}.to_n)
-        progress_bar.start
-        `$(document).trigger('page:click')`
-        $window.history.push href, pjax: true
-      end
-
-      on :click, 'a' do |el, evt|
-        href = el.attr 'href'
-
-        unless href =~ /^#/i || href =~ /^javascript:/i || el.attr('target') == '_blank'
-          evt.prevent_default
-          get href
-        end
-      end
-
-      on :history_change do |e|
-        if e.data.pjax
-          progress_bar.start
-          `$(document).trigger('page:request')`
-          HTTP.get(e.url) do |response|
-            res  = Native(response.xhr)
-            html = res.responseText
-            # grab and add the body
-            matches = html.match(/<body[^>]*>((.|[\n\r])*)<\/body>/im)
-            dom.find('body').html matches[1]
-            # grab and eval the scripts
-            matches = html.match(/<script>((.|[\n\r])*)<\/script>/im)
-            # `eval(#{matches[0]})`
-            (matches[1] || '').split('</script>').each do |script|
-              # script = script.sub('<script>', '')
-              script = script.strip.sub('</html>', '').sub('<script>', '')
-              `jQuery.globalEval(script);`
-            end
-            progress_bar.finish
-            `$('html, body').animate({ scrollTop: 0 }, 0); $(document).trigger('page:load');`
-          end
-        end
-      end
-    end
-  end
-end

data/lib/browserio/plugins/validations.rb

@@ -1,251 +0,0 @@
-module BrowserIO
-  module Plugins
-    class Form < Component
-      # Provides a base implementation for extensible validation routines.
-      # {Scrivener::Validations} currently only provides the following assertions:
-      #
-      # * assert
-      # * assert_present
-      # * assert_format
-      # * assert_numeric
-      # * assert_url
-      # * assert_email
-      # * assert_member
-      # * assert_length
-      # * assert_decimal
-      # * assert_equal
-      #
-      # The core tenets that Scrivener::Validations advocates can be summed up in a
-      # few bullet points:
-      #
-      # 1. Validations are much simpler and better done using composition rather
-      #    than macros.
-      # 2. Error messages should be kept separate and possibly in the view or
-      #    presenter layer.
-      # 3. It should be easy to write your own validation routine.
-      #
-      # Other validations are simply added on a per-model or per-project basis.
-      #
-      # @example
-      #
-      #   class Quote
-      #     attr_accessor :title
-      #     attr_accessor :price
-      #     attr_accessor :date
-      #
-      #     def validate
-      #       assert_present :title
-      #       assert_numeric :price
-      #       assert_format  :date, /\A[\d]{4}-[\d]{1,2}-[\d]{1,2}\z
-      #     end
-      #   end
-      #
-      #   s = Quote.new
-      #   s.valid?
-      #   # => false
-      #
-      #   s.errors
-      #   # => { :title => [:not_present],
-      #          :price => [:not_numeric],
-      #          :date  => [:format] }
-      #
-      module Validations
-        def server? &block
-          RUBY_ENGINE == 'ruby'
-        end
-        alias :server :server?
-
-        def client?
-          RUBY_ENGINE == 'opal'
-        end
-        alias :client :client?
-
-        def self.server? &block
-          RUBY_ENGINE == 'ruby'
-        end
-        alias :server :server?
-
-        def self.client?
-          RUBY_ENGINE == 'opal'
-        end
-        alias :client :client?
-
-        # Check if the current model state is valid. Each call to {#valid?} will
-        # reset the {#errors} array.
-        #
-        # All validations should be declared in a `validate` method.
-        #
-        # @example
-        #
-        #   class Login
-        #     attr_accessor :username
-        #     attr_accessor :password
-        #
-        #     def validate
-        #       assert_present :user
-        #       assert_present :password
-        #     end
-        #   end
-        #
-        def valid?
-          errors.clear
-          validate
-          errors.empty?
-        end
-
-        # Base validate implementation. Override this method in subclasses.
-        def validate
-        end
-
-        # Hash of errors for each attribute in this model.
-        def errors
-          @errors ||= Hash.new { |hash, key| hash[key] = [] }
-        end
-
-        protected
-
-        # Allows you to do a validation check against a regular expression.
-        # It's important to note that this internally calls {#assert_present},
-        # therefore you need not structure your regular expression to check
-        # for a non-empty value.
-        #
-        # @param [Symbol] att The attribute you want to verify the format of.
-        # @param [Regexp] format The regular expression with which to compare
-        #                 the value of att with.
-        # @param [Array<Symbol, Symbol>] error The error that should be returned
-        #                                when the validation fails.
-        def assert_format(att, format, error = [att, :format])
-          if assert_present(att, error)
-            assert(_attributes.send(att).to_s.match(format), error)
-          end
-        end
-
-        # The most basic and highly useful assertion. Simply checks if the
-        # value of the attribute is empty.
-        #
-        # @param [Symbol] att The attribute you wish to verify the presence of.
-        # @param [Array<Symbol, Symbol>] error The error that should be returned
-        #                                when the validation fails.
-        def assert_present(att, error = [att, :not_present])
-          if att.is_a? Array
-            att.each { |a| assert_present(a, error = [a, :not_present])}
-          else
-            if klass = _form[att]
-              options = {}
-              options[:key] = _options[:key] if _options.key? :key
-
-              f = klass.new(_attributes.send(att).attributes, options)
-              assert(f.valid?, [att, f.errors])
-            else
-              assert(!_attributes.send(att).to_s.empty?, error)
-            end
-          end
-        end
-
-        # Checks if all the characters of an attribute is a digit.
-        #
-        # @param [Symbol] att The attribute you wish to verify the numeric format.
-        # @param [Array<Symbol, Symbol>] error The error that should be returned
-        #                                when the validation fails.
-        def assert_numeric(att, error = [att, :not_numeric])
-          if assert_present(att, error)
-            if client?
-              assert_format(att, /^\-?\d+$/, error)
-            else
-              assert_format(att, /\A\-?\d+\z/, error)
-            end
-          end
-        end
-
-        if client?
-          URL = /^(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(2 5[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3} |localhost)(:[0-9]{1,5})?(\/.*)?$/i
-        else
-          URL = /\A(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(2 5[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3} |localhost)(:[0-9]{1,5})?(\/.*)?\z/i
-        end
-
-        def assert_url(att, error = [att, :not_url])
-          if assert_present(att, error)
-            assert_format(att, URL, error)
-          end
-        end
-
-        if client?
-          EMAIL = /^[a-z0-9!\#$%&'*\/=\?^{|}+_-]+(?:\.[a-z0-9!\#$%&'*\/=\?^{|}+_-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i
-        else
-          EMAIL = /\A[a-z0-9!\#$%&'*\/=\?^{|}+_-]+(?:\.[a-z0-9!\#$%&'*\/=\?^{|}+_-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\z/i
-        end
-
-        def assert_email(att, error = [att, :not_email])
-          if assert_present(att, error)
-            assert_format(att, EMAIL, error)
-          end
-        end
-
-        def assert_member(att, set, err = [att, :not_valid])
-          assert(set.include?(_attributes.send(att)), err)
-        end
-
-        def assert_length(att, range, error = [att, :not_in_range])
-          if assert_present(att, error)
-            val = _attributes.send(att).to_s
-            assert range.include?(val.length), error
-          end
-        end
-
-        if client?
-          DECIMAL = /^\-?(\d+)?(\.\d+)?$/
-        else
-          DECIMAL = /\A\-?(\d+)?(\.\d+)?\z/
-        end
-
-        def assert_decimal(att, error = [att, :not_decimal])
-          assert_format att, DECIMAL, error
-        end
-
-        # Check that the attribute has the expected value. It uses === for
-        # comparison, so type checks are possible too. Note that in order
-        # to make the case equality work, the check inverts the order of
-        # the arguments: `assert_equal :foo, Bar` is translated to the
-        # expression `Bar === send(:foo)`.
-        #
-        # @example
-        #
-        #   def validate
-        #     assert_equal :status, "pending"
-        #     assert_equal :quantity, Fixnum
-        #   end
-        #
-        # @param [Symbol] att The attribute you wish to verify for equality.
-        # @param [Object] value The value you want to test against.
-        # @param [Array<Symbol, Symbol>] error The error that should be returned
-        #                                when the validation fails.
-        def assert_equal(att, value, error = [att, :not_equal])
-          assert value === _attributes.send(att), error
-        end
-
-        # The grand daddy of all assertions. If you want to build custom
-        # assertions, or even quick and dirty ones, you can simply use this method.
-        #
-        # @example
-        #
-        #   class CreatePost
-        #     attr_accessor :slug
-        #     attr_accessor :votes
-        #
-        #     def validate
-        #       assert_slug :slug
-        #       assert votes.to_i > 0, [:votes, :not_valid]
-        #     end
-        #
-        #   protected
-        #     def assert_slug(att, error = [att, :not_slug])
-        #       assert send(att).to_s =~ /\A[a-z\-0-9]+\z/, error
-        #     end
-        #   end
-        def assert(value, error)
-          value or errors[error.first].push(error.last) && false
-        end
-      end
-    end
-  end
-end