wedge 0.1.17 → 0.1.18

data/lib/wedge/plugins/render.rb

@@ -0,0 +1,110 @@
+class Wedge
+  module Plugins
+    module Render
+      def display_errors options = {}, &block
+        dom = options.delete(:dom) || _options[: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']
+          next if name.nil?
+          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 != false ? 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 _error_name key, error
+        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
+    end
+  end
+end

data/lib/wedge/plugins/uploader.rb

@@ -3,10 +3,10 @@ class Wedge
     class Uploader < Component
       name :uploader, :uploader_plugin
 
-      on :compile do
+      on :compile do |for_client|
         settings = Wedge.config.settings[:uploader]
         store[:settings] = settings.select do |k, v|
-          client? ? %w(aws_access_key_id bucket).include?(k) : true
+          for_client ? %i(aws_access_key_id bucket).include?(k) : true
         end if settings
       end
 

data/lib/wedge/utilis/duplicable.rb

@@ -0,0 +1,104 @@
+#--
+# Most objects are cloneable, but not all. For example you can't dup +nil+:
+#
+#   nil.dup # => TypeError: can't dup NilClass
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+#++
+class Object
+  # Can you safely dup this object?
+  #
+  # False for +nil+, +false+, +true+, symbol, number objects;
+  # true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+# fix: this is a current hack, as of opal 0.8 you can't #dup/#clone procs
+if RUBY_ENGINE == 'opal'
+  class Proc
+    def duplicable?
+      false
+    end
+  end
+end
+
+class NilClass
+  # +nil+ is not duplicable:
+  #
+  #   nil.duplicable? # => false
+  #   nil.dup         # => TypeError: can't dup NilClass
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass
+  # +false+ is not duplicable:
+  #
+  #   false.duplicable? # => false
+  #   false.dup         # => TypeError: can't dup FalseClass
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass
+  # +true+ is not duplicable:
+  #
+  #   true.duplicable? # => false
+  #   true.dup         # => TypeError: can't dup TrueClass
+  def duplicable?
+    false
+  end
+end
+
+class Symbol
+  # Symbols are not duplicable:
+  #
+  #   :my_symbol.duplicable? # => false
+  #   :my_symbol.dup         # => TypeError: can't dup Symbol
+  def duplicable?
+    false
+  end
+end
+
+class Numeric
+  # Numbers are not duplicable:
+  #
+  #  3.duplicable? # => false
+  #  3.dup         # => TypeError: can't dup Fixnum
+  def duplicable?
+    false
+  end
+end
+
+defined?(::BigDecimal) or require 'bigdecimal' unless  RUBY_ENGINE == 'opal'
+
+class BigDecimal
+  def duplicable?
+    true
+  end
+end
+
+class Method
+  # Methods are not duplicable:
+  #
+  #  method(:puts).duplicable? # => false
+  #  method(:puts).dup         # => TypeError: allocator undefined for Method
+  def duplicable?
+    false
+  end
+end

data/lib/wedge/utilis/hash.rb

@@ -1,3 +1,5 @@
+require_relative 'duplicable'
+
 class Hash
   # add keys to hash
   def to_obj
@@ -103,3 +105,49 @@ class HashObject
     Wedge::IndifferentHash.new self.to_h.inject({}) {|copy, (key, value)| copy[key] = value.dup rescue value; copy}
   end
 end
+
+class Object
+  # Returns a deep copy of object if it's duplicable. If it's
+  # not duplicable, returns +self+.
+  #
+  #   object = Object.new
+  #   dup    = object.deep_dup
+  #   dup.instance_variable_set(:@a, 1)
+  #
+  #   object.instance_variable_defined?(:@a) # => false
+  #   dup.instance_variable_defined?(:@a)    # => true
+  def deep_dup
+    duplicable? ? dup : self
+  end
+end
+
+class Array
+  # Returns a deep copy of array.
+  #
+  #   array = [1, [2, 3]]
+  #   dup   = array.deep_dup
+  #   dup[1][2] = 4
+  #
+  #   array[1][2] # => nil
+  #   dup[1][2]   # => 4
+  def deep_dup
+    map(&:deep_dup)
+  end
+end
+
+class Hash
+  # Returns a deep copy of hash.
+  #
+  #   hash = { a: { b: 'b' } }
+  #   dup  = hash.deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] # => nil
+  #   dup[:a][:c]  # => "c"
+  def deep_dup
+    each_with_object(dup) do |(key, value), hash|
+      hash.delete(key)
+      hash[key.deep_dup] = value.deep_dup
+    end
+  end
+end

data/lib/wedge/version.rb

@@ -1,3 +1,3 @@
 class Wedge
-  VERSION = '0.1.17'
+  VERSION = '0.1.18'
 end

data/playground/app/app.rb

@@ -1,6 +1,9 @@
 class Playground
   use Rack::Session::Cookie, secret: APP_SECRET
+  # gzips assets
+  use Rack::Deflater, include: %w{text/plain application/xml application/json application/javascript text/css text/json}
 
+  plugin :middleware
   plugin :environments
 
   configure :development do
@@ -13,17 +16,26 @@ class Playground
     BetterErrors.application_root = Dir.pwd
   end
 
-  plugin :wedge, {
-    scope: self,
-    plugins: [:form],
-    settings: {
-      uploader: {
-        aws_access_key_id: AWS_ACCESS_KEY_ID,
-        aws_secret_access_key: AWS_SECRET_ACCESS_KEY,
-        bucket: AWS_BUCKET
-      }
+  plugin :csrf, skip_if: ->(_) { RACK_ENV == 'test' }
+  plugin :wedge do |c|
+    c.scope = Playground
+    c.debug = true
+    c.app_dir = RACK_ENV != 'test' ? 'app' : 'playground/app'
+    c.plugin :form
+    c.plugin :current_user, client_fields: %w'id first_name last_name is_admin' do
+      User.find(1)
+    end
+    # c.plugin_settings :uploader, {
+    #   aws_access_key_id: AWS_ACCESS_KEY_ID,
+    #   aws_secret_access_key: AWS_SECRET_ACCESS_KEY,
+    #   bucket: AWS_BUCKET
+    # }
+    c.settings[:uploader] = {
+      aws_access_key_id: AWS_ACCESS_KEY_ID,
+      aws_secret_access_key: AWS_SECRET_ACCESS_KEY,
+      bucket: AWS_BUCKET
     }
-  }
+  end
 
   # builder = Opal::Builder.new(:stubs=>['opal'])
   # builder.append_paths(APP_ROOT)
@@ -49,7 +61,7 @@ class Playground
   }
 
   route do |r|
-    r.wedge_assets
+    # r.wedge_assets
     r.assets
 
     r.root do
@@ -59,5 +71,9 @@ class Playground
     r.on 'uploader' do
       wedge(:uploader).to_js :display
     end
+
+    r.on 'todo_list' do
+      wedge(:todo_list).to_js :display
+    end
   end
 end

data/playground/app/components/abilities.rb

@@ -0,0 +1,11 @@
+class Playground
+  class Abilities < Wedge::Plugins::AbilityList
+    name :ability_list
+
+    def initialize user
+      if user.admin?
+        can :view, :admin
+      end
+    end
+  end
+end

data/playground/app/components/current_user.rb

@@ -0,0 +1,12 @@
+class Playground
+  class CurrentUserComponent < Wedge::Plugins::CurrentUser
+    name :current_user
+
+    attr_reader :id, :is_admin, :secret_key
+    attr_accessor :first_name, :last_name
+
+    def admin?
+      is_admin
+    end
+  end
+end

data/playground/app/components/layout.rb

@@ -29,9 +29,14 @@ class Playground
     def display options = {}, &block
       return unless server?
 
+      begin; dom.find('head').add_child csrf_metatag; rescue; end
       body_dom = dom.find('body')
       body_dom << block.call if block_given?
 
+      if body_class = options[:body_class]
+        body_dom.add_class body_class
+      end
+
       dom
     end
   end

data/playground/app/components/todo_list.rb

@@ -0,0 +1,24 @@
+require_relative '../forms/todo_list_add'
+
+class Playground
+  class TodoListComponent < Wedge::Component
+    name :todo_list
+    html 'public/todo_list.html'
+
+    def display
+      wedge(:layout).display(body_class: 'todo_list') { dom } if server?
+    end
+
+    on :submit, '#add-form', key: :todo, form: :todo_list_add do |form, el|
+      button = el.find('button[type="submit"]')
+      button.prop("disabled", true)
+      if form.valid?
+        puts 'valid'
+      else
+        form.display_errors
+        button.prop("disabled", false)
+        puts 'errors'
+      end
+    end
+  end
+end

data/playground/app/config/boot.rb

@@ -17,3 +17,6 @@ require 'app'
 
 Dir["#{APP_ROOT}/forms/*.rb"].sort.each { |file| require file }
 Dir["#{APP_ROOT}/components/*.rb"].sort.each { |file| require file }
+Dir["#{APP_ROOT}/models/*.rb"].sort.each { |file| require file }
+
+require './spec/spec_helper' if RACK_ENV == 'test'

data/playground/app/forms/todo_list_add.rb

@@ -0,0 +1,9 @@
+class TodoListAddForm < Wedge::Plugins::Form
+  name :todo_list_add
+
+  attr_accessor :description
+
+  def validate
+    assert_present :description
+  end
+end

data/playground/app/models/user.rb

@@ -0,0 +1,5 @@
+class Playground
+  class User
+
+  end
+end