wedge 0.0.1

data/lib/wedge/plugins/history.rb

@@ -0,0 +1,92 @@
+module Wedge
+  module Plugins
+    class History < Component
+      config.name :history_plugin
+    end
+  end
+end
+
+if RUBY_ENGINE == 'opal'
+  require 'wedge/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/wedge/plugins/location.rb

@@ -0,0 +1,78 @@
+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/wedge/plugins/pjax.rb

@@ -0,0 +1,65 @@
+module Wedge
+  module Plugins
+    class Pjax < Component
+      config.name :pjax, :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/wedge/plugins/validations.rb

@@ -0,0 +1,251 @@
+module Wedge
+  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