wedgeio 0.0.1

data/lib/wedge/utilis/nokogiri.rb

@@ -0,0 +1,44 @@
+module Nokogiri
+  module XML
+    class NodeSet
+      # fix: this is really shity
+      # alias_method :original_to_html, :to_html
+      # def to_html *args
+      #   original_to_html(*args).gsub('%7B', "{").gsub('%7D', "}")
+      # end
+    end
+    class Node
+      # fix: this is really shity
+      # alias_method :original_to_html, :to_html
+      # def to_html *args
+      #   original_to_html(*args).gsub('%7B', "{").gsub('%7D', "}")
+      # end
+
+      private
+
+      def coerce data # :nodoc:
+        if data.class.to_s == 'Wedge::DOM'
+          data = data.dom
+        end
+
+        case data
+        when XML::NodeSet
+          return data
+        when XML::DocumentFragment
+          return data.children
+        when String
+          return fragment(data).children
+        when Document, XML::Attr
+          # unacceptable
+        when XML::Node
+          return data
+        end
+
+        raise ArgumentError, <<-EOERR
+Requires a Node, NodeSet or String argument, and cannot accept a #{data.class}.
+(You probably want to select a node from the Document with at() or search(), or create a new Node via Node.new().)
+        EOERR
+      end
+    end
+  end
+end

data/lib/wedge/utilis/titleize.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# Adds String#titleize for creating properly capitalized titles.
+# It can be called as Titleize.titleize or "a string".titleize.
+#
+# titlecase is included as an alias for titleize.
+#
+# If loaded in a Rails environment, it modifies Inflector.titleize.
+module Titleize
+  SMALL_WORDS = %w{a an and as at but by en for if in of on or the to v v. via vs vs.}
+
+  extend self
+
+  # Capitalizes most words to create a nicer looking title string.
+  #
+  # The list of "small words" which are not capped comes from
+  # the New York Times Manual of Style, plus 'vs' and 'v'.
+  #
+  #   "notes on a scandal" # => "Notes on a Scandal"
+  #   "the good german"    # => "The Good German"
+  def titleize(title)
+    title = title.dup
+    title.downcase! unless title[/[[:lower:]]/]  # assume all-caps need fixing
+
+    phrases(title).map do |phrase|
+      words = phrase.split
+      words.map do |word|
+        def word.capitalize
+          # like String#capitalize, but it starts with the first letter
+          self.sub(/[[:alpha:]].*/) {|subword| subword.capitalize}
+        end
+
+        case word
+        when /[[:alpha:]]\.[[:alpha:]]/  # words with dots in, like "example.com"
+          word
+        when /[-‑]/  # hyphenated word (regular and non-breaking)
+          word.split(/([-‑])/).map do |part|
+            SMALL_WORDS.include?(part) ? part : part.capitalize
+          end.join
+        when /^[[:alpha:]].*[[:upper:]]/ # non-first letter capitalized already
+          word
+        when /^[[:digit:]]/  # first character is a number
+          word
+        when words.first, words.last
+          word.capitalize
+        when *(SMALL_WORDS + SMALL_WORDS.map {|small| small.capitalize })
+          word.downcase
+        else
+          word.capitalize
+        end
+      end.join(" ")
+    end.join(" ")
+  end
+
+  # Splits a title into an array based on punctuation.
+  #
+  #   "simple title"              # => ["simple title"]
+  #   "more complicated: titling" # => ["more complicated:", "titling"]
+  def phrases(title)
+    phrases = title.scan(/.+?(?:[:.;?!] |$)/).map {|phrase| phrase.strip }
+
+    # rejoin phrases that were split on the '.' from a small word
+    if phrases.size > 1
+      phrases[0..-2].each_with_index do |phrase, index|
+        if SMALL_WORDS.include?(phrase.split.last.downcase)
+          phrases[index] << " " + phrases.slice!(index + 1)
+        end
+      end
+    end
+
+    phrases
+  end
+end
+
+class String
+  # Capitalizes most words to create a nicer looking title string.
+  #
+  # The list of "small words" which are not capped comes from
+  # the New York Times Manual of Style, plus 'vs' and 'v'.
+  #
+  # titleize is also aliased as titlecase.
+  #
+  #   "notes on a scandal" # => "Notes on a Scandal"
+  #   "the good german"    # => "The Good German"
+  def titleize(opts={})
+    # if defined? ActiveSupport
+    #   ActiveSupport::Inflector.titleize(self, opts)
+    # else
+      Titleize.titleize(self)
+    # end
+  end
+  alias_method :titlecase, :titleize
+
+  def titleize!
+    replace(titleize)
+  end
+  alias_method :titlecase!, :titleize!
+end

data/lib/wedge/utilis/try.rb

@@ -0,0 +1,106 @@
+class Object
+  # Invokes the public method whose name goes as first argument just like
+  # +public_send+ does, except that if the receiver does not respond to it the
+  # call returns +nil+ rather than raising an exception.
+  #
+  # This method is defined to be able to write
+  #
+  #   @person.try(:name)
+  #
+  # instead of
+  #
+  #   @person.name if @person
+  #
+  # +try+ calls can be chained:
+  #
+  #   @person.try(:spouse).try(:name)
+  #
+  # instead of
+  #
+  #   @person.spouse.name if @person && @person.spouse
+  #
+  # +try+ will also return +nil+ if the receiver does not respond to the method:
+  #
+  #   @person.try(:non_existing_method) # => nil
+  #
+  # instead of
+  #
+  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) # => nil
+  #
+  # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
+  # to the method:
+  #
+  #   nil.try(:to_i) # => nil, rather than 0
+  #
+  # Arguments and blocks are forwarded to the method if invoked:
+  #
+  #   @posts.try(:each_slice, 2) do |a, b|
+  #     ...
+  #   end
+  #
+  # The number of arguments in the signature must match. If the object responds
+  # to the method the call is attempted and +ArgumentError+ is still raised
+  # in case of argument mismatch.
+  #
+  # If +try+ is called without arguments it yields the receiver to a given
+  # block unless it is +nil+:
+  #
+  #   @person.try do |p|
+  #     ...
+  #   end
+  #
+  # You can also call try with a block without accepting an argument, and the block
+  # will be instance_eval'ed instead:
+  #
+  #   @person.try { upcase.truncate(50) }
+  #
+  # Please also note that +try+ is defined on +Object+. Therefore, it won't work
+  # with instances of classes that do not have +Object+ among their ancestors,
+  # like direct subclasses of +BasicObject+. For example, using +try+ with
+  # +SimpleDelegator+ will delegate +try+ to the target instead of calling it on
+  # the delegator itself.
+  def try(*a, &b)
+    try!(*a, &b) if a.empty? || respond_to?(a.first)
+  end
+
+  # Same as #try, but raises a NoMethodError exception if the receiver is
+  # not +nil+ and does not implement the tried method.
+  #
+  #   "a".try!(:upcase) # => "A"
+  #   nil.try!(:upcase) # => nil
+  #   123.try!(:upcase) # => NoMethodError: undefined method `upcase' for 123:Fixnum
+  def try!(*a, &b)
+    if a.empty? && block_given?
+      if b.arity.zero?
+        instance_eval(&b)
+      else
+        yield self
+      end
+    else
+      public_send(*a, &b)
+    end
+  end
+end
+
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes especially helpful when navigating through associations that may return +nil+.
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && @person.children.any? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
+  def try(*args)
+    nil
+  end
+
+  # Calling +try!+ on +nil+ always returns +nil+.
+  #
+  #   nil.try!(:name) # => nil
+  def try!(*args)
+    nil
+  end
+end

data/lib/wedge/version.rb

@@ -0,0 +1,3 @@
+module Wedge
+  VERSION = "0.0.1"
+end

data/test.rb

@@ -0,0 +1,44 @@
+require 'awesome_print'
+
+requires = {
+  form_plugin: [],
+  list: [
+    {
+      name: 'claim',
+      requires: [
+        {name: 'filter_form', requires: [{ name: 'form_plugin', requires: [] }]},
+        {name: 'claim_form', requires: []}
+      ],
+    },
+    {
+      name: 'claim_form',
+      requires: [
+        {name: 'form_plugin', requires: []},
+        {name: 'address_form', requires: [{ name: 'form_plugin', requires: [] }]}
+      ],
+    }
+  ]
+}
+
+$loaded_requires = []
+
+def get_requires reqs, requires_array = []
+  new_reqs = []
+
+  reqs.each do |r|
+    if r[:requires].any?
+      get_requires(r[:requires], requires_array)
+    end
+
+    unless $loaded_requires.include? r[:name]
+      $loaded_requires << r[:name]
+      new_reqs         << r[:name]
+    end
+  end
+
+  requires_array << new_reqs if new_reqs.any?
+
+  requires_array
+end
+
+ap get_requires requires[:list]

data/test/dummy/app.rb

@@ -0,0 +1,34 @@
+require 'wedge'
+require 'roda'
+
+require 'pry'
+require 'awesome_print'
+
+ROOT_PATH = File.dirname(__FILE__)
+
+class DummyApp < Roda
+  plugin :wedge, {
+    scope: self,
+    plugins: [:form]
+  }
+
+  plugin :assets, {
+    group_subdirs: false,
+    path: ROOT_PATH,
+    css_dir: '',
+    js_dir: ''
+  }
+
+  route do |r|
+    r.wedge_assets
+
+    r.root do
+      wedge(:root, :js).display
+    end
+  end
+end
+
+Dir["#{ROOT_PATH}/forms/*.rb"].sort.each { |file| require file }
+Dir["#{ROOT_PATH}/components/*.rb"].sort.each { |file| require file }
+
+Wedge.cache # cache files on app load

data/test/dummy/components/bar.rb

@@ -0,0 +1,14 @@
+class DummyApp
+  class BarComponent < Wedge::Component
+    config.name :bar
+    config.requires :root, :base
+
+    def moo
+      'cow'
+    end
+
+    on :clicked_foo, for: :root do
+      dom.find('body').append moo
+    end
+  end
+end

data/test/dummy/components/base.rb

@@ -0,0 +1,5 @@
+class DummyApp
+  class BaseComponent < Wedge::Component
+    config.name :base
+  end
+end

data/test/dummy/components/root.rb

@@ -0,0 +1,42 @@
+require_relative 'base' unless RUBY_ENGINE == 'opal'
+
+class DummyApp
+  class RootComponent < BaseComponent
+    config.name :root
+    config.html <<-HTML
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <script src="//code.jquery.com/jquery-1.11.2.js"></script>
+          #{Wedge.script_tag}
+        </head>
+        <body>
+          <div id='foo'>bar</div>
+        </body>
+      </html>
+    HTML
+    config.dom do
+      dom.find('body') << assets(:js)
+    end
+    config.requires :base, :bar, :foo_form, :pjax_plugin
+
+    def display
+      if server?
+        dom
+      else
+        el = Element['<div>']
+        el.html 'foo'
+        dom.find('#foo').before el
+      end
+    end
+
+    on :ready do
+      puts 'dom ready'
+    end
+
+    on :click, '#foo' do |el|
+      el.after '<div>bar</div>'
+      trigger :clicked_foo
+    end
+  end
+end

data/test/dummy/config.ru

@@ -0,0 +1,6 @@
+require 'bundler'
+Bundler.setup :default, ENV.fetch('RACK_ENV') { 'development' }
+
+require_relative 'app'
+
+run DummyApp

data/test/dummy/forms/bar.rb

@@ -0,0 +1,5 @@
+class DummyApp
+  class BarForm < Wedge::Plugins::Form
+    config.name :bar_form
+  end
+end

data/test/dummy/forms/foo.rb

@@ -0,0 +1,6 @@
+class DummyApp
+  class FooForm < Wedge::Plugins::Form
+    config.name :foo_form
+    config.requires :bar_form
+  end
+end

data/test/test.js

@@ -0,0 +1,59 @@
+var page = require('webpage').create();
+page.settings.localToRemoteUrlAccessEnabled = true;
+page.settings.resourceTimeout = 1000;
+// page.content = "<!doctype html>\n<html>\n<head>\new<script type=\"text/javascript\" src=\"https://code.jquery.com/jquery-1.11.2.min.js\"></script>\n</head>\n<body>\n<div id=\"foo\">bar<div>\n</body>\n</html>";
+var content = '<!doctype html>';
+content += '<html><head>';
+content += '<script type="text/javascript" src="https://code.jquery.com/jquery-1.11.2.min.js"></script>';
+content += '</head><body>';
+content += '<h1 id="foo">bar</h1>';
+content += '</body></html>';
+
+// page.content = "<div id='foo'>bar</div>";
+
+page.onConsoleMessage = function(msg) {
+  console.log(msg);
+};
+
+page.onResourceTimeout = function(a) {
+  phantom.exit(1);
+};
+
+page.onError = function(msg, trace) {
+
+  var msgStack = ['ERROR: ' + msg];
+
+  if (trace && trace.length) {
+    msgStack.push('TRACE:');
+    trace.forEach(function(t) {
+      msgStack.push(' -> ' + t.file + ': ' + t.line + (t.function ? ' (in function "' + t.function +'")' : ''));
+    });
+  }
+
+  console.log(msgStack.join('\n'));
+  phantom.exit();
+};
+
+phantom.onError = function(msg, trace) {
+  var msgStack = ['PHANTOM ERROR: ' + msg];
+  if (trace && trace.length) {
+    msgStack.push('TRACE:');
+    trace.forEach(function(t) {
+      msgStack.push(' -> ' + (t.file || t.sourceURL) + ': ' + t.line + (t.function ? ' (in function ' + t.function +')' : ''));
+    });
+  }
+  console.log(msgStack.join('\n'));
+  phantom.exit();
+};
+
+page.content = content
+
+page.onLoadFinished = function() {
+  page.evaluate(function() {
+    console.log($('#foo').html());
+  });
+  phantom.exit();
+};
+
+// page.includeJs("http://code.jquery.com/jquery-1.11.2.min.js", function(){
+// });