webface_rails 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1cc42fc92095e740deb07c81294310846908ebd80d435bc1bc0873578185c978
+  data.tar.gz: 690639b7c31b20ca0e9ccda60410a6629e495d1bdecc3f05fb3a0cd7ad8dff4f
+SHA512:
+  metadata.gz: 1fd031041de3a7740a6639ce52b45832399ea462766382b93d3237fb51b1ead330cdeb361cf97274850e91c81444eeb7ca2e5465042d9b8ee81915307fc00503
+  data.tar.gz: c9b256dde5c1acc4f734598ba188df1b0f99f2ef1da5196386b40b23b906cd11269a4d478db2edd0dea8ab78426a4cb31ffd612fabf9a873bed4d1c4a5b8bcaf

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 Roman Snitko
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# WebfaceRails
+RubyOnRails integration with Webface.js
+
+Installation
+------------
+add `gem 'webface_rails'` to Gemfile and run `bundle install`
+
+Running generators
+------------------
+To run the generator:
+
+`rails generate webface` or `rails g webface`
+
+By default it uses `Rails.root` path to install the gem. You can pass `root_path` argument to redefine root path in your project. It might be helpful when installing the gem into Rails Engine, e.g.:
+
+`rails g webface --root_path absolute_path_to_your_project`
+
+The generator will give you necessary files and dir structure inside the `spec/` dir to
+run webface tests. To be more specific, it will do the following
+
+1. Install webface as a submodule under `app/assets/javascripts/webface.js`. If you already have it installed, it will use the path specified in .gitmodules
+2. Create webface unit test dir under `spec/webface`
+3. Copy there a bunch of files necessary to run unit tests
+4. Add `node_modules` dirs to .gitignore
+5. Symlink your `app/assets/javascripts` into `spec/webface/source` and `app/assets/javascripts` into `spec/webface/webface_source`. This is necessary to properly import the files you're testing.
+6. Install node_modules in `app/assets/javascripts`. If it doesn't have a `package.json` file, it will copy the one used by webface.
+7. Symlink `app/assets/javascripts/node_modules` to `spec/webface/node_modules`
+8. And finally, symlink the `app/assets/javascripts/webface.js` (or whatever the path is) into `spec/webface/webface_source`
+
+Running unit tests
+------------------
+After you run the generators, you should be able to run unit tests with
+a) `spec/webface/run_test` or
+b) by launching the test server with `node spec/webface/test_server.js` and navigating your browser to `localhost:8080`. You should see a sample test there.
+
+Look at the `spec/webface/components/my_component.test.js` file for examples on how to write unit tests.
+Unit tests are written with mocha & chai.

data/Rakefile

@@ -0,0 +1,7 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'bundler/gem_tasks'

data/app/controllers/webface_error_report_controller.rb

@@ -0,0 +1,12 @@
+class WebfaceErrorReportController < ApplicationController
+
+  def report
+    puts "**********************************"
+    puts "Frontend error detected. Please make sure you redefine this action\n" +
+         "to actually report this error to something like Sentry!\n" +
+         "below are the params that were sent by Webface Logmaster:"
+    p params
+    puts "**********************************"
+  end
+
+end

data/app/helpers/webface_component_helper.rb

@@ -0,0 +1,248 @@
+module WebfaceComponentHelper
+
+  def webface(tag_name, component: nil, attrs: {})
+
+    component = "#{component.to_s.camelize}Component" unless component.nil?
+
+    if attrs[:property_attr]
+      property_attrs = attrs[:property_attr].split(/,\s*?/)
+      property_attrs.map! { |a| "#{a.strip}:data-#{a.strip.gsub("_","-")}" }
+      attrs[:property_attr] = property_attrs.join(", ")
+    end
+
+    # convert short data attribute names to proper longer ones
+    webface_data = {}
+    webface_data[:component_class]                = component
+    webface_data[:component_property]             = attrs.delete(:property)
+    webface_data[:component_part]                 = attrs.delete(:part)
+    webface_data[:component_roles]                = attrs.delete(:roles)
+    webface_data[:component_attribute_properties] = attrs.delete(:property_attr)
+    webface_data[:component_display_value]        = attrs.delete(:display)
+
+    content_tag(tag_name, { data: webface_data.merge(attrs.delete(:data) || {})}.merge(attrs)) do
+      yield if block_given?
+    end
+  end
+
+  def component(name, attrs={}, &block)
+    render partial: "webface_components/#{name}", locals: { options: attrs.delete(:options) || {}, attrs: attrs, block: block }
+  end
+
+  def component_block(component, tag_name="div", attrs={}, &block)
+    webface(tag_name, component: component, attrs: attrs, &block)
+  end
+
+  def property(property, tag_name="span", attrs={}, &block)
+    webface(tag_name, attrs: attrs.merge({ property: property}), &block)
+  end
+
+  def component_part(part_name, tag_name="div", attrs={}, &block)
+    webface(tag_name, attrs: attrs.merge({ part: part_name}), &block)
+  end
+
+  def button_link(caption, path, options={})
+    component_block (options[:confirmation] ? "confirmable_button" : "button"), "a", { class: "button", href: path, data: { prevent_native_click_event: "false", component_attribute_propertie: "lockable,disabled,confirmation,prevent_native_click_event", component_property: "caption" }}.merge(options) do
+      caption
+    end
+  end
+
+  def component_form(model, action=nil, attrs={}, &block)
+
+    if model.new_record?
+      action = send("#{model.class.to_s.underscore.pluralize}_path") unless action
+      method_field = ""
+    else
+      action = send("#{model.class.to_s.underscore}_path", model.to_param) unless action
+      method_field = content_tag(:input, "", type: "hidden", name: "_method", value: "PATCH")
+    end
+
+    method_field = content_tag(:input, "", type: "hidden", name: "_method", value: attrs.delete(:method)) if attrs[:method]
+
+    auth_token_field = content_tag(:input, "", value: form_authenticity_token, type: "hidden", name: "authenticity_token")
+
+    f = WebfaceForm.new(model, self)
+    content = capture(f, &block)
+    content_tag(:form, { action: action, method: 'POST', "accept-charset" => "UTF-8", "enctype" => "multipart/form-data" }.merge(attrs)) do
+      concat content
+      concat method_field
+      concat auth_token_field
+    end
+  end
+
+  def post_button_link(caption, path, verb, options={})
+    render partial: "webface_components/post_button_link", locals: { caption: caption, path: path, verb: verb, options: options }
+  end
+
+  # Attention! This method changes attrs passed to it,
+  # as if `attrs` was passed by reference! That's why we use `eval` and
+  # binding.
+  def data_attrs_and_values!(attrs, bdg, names=[])
+    data_hash = {}
+    names.each do |n|
+      data_hash[n] = eval("attrs.delete(:#{n})", bdg)
+    end
+    data_hash
+  end
+
+  def component_template(name, tag_name="div", attrs={}, &block)
+    attrs[:data] ||= {}
+    attrs[:data][:component_template] = "#{name.to_s.camelize}Component"
+    component_block(nil, tag_name, attrs, &block)
+  end
+
+  def prepare_select_collection(c, selected: nil, blank_option: false)
+
+    if c
+      collection = c.dup
+    else
+      return []
+    end
+
+    if collection.kind_of?(Array)
+      if !collection[0].kind_of?(Array)
+        collection.map! { |option| [option, option] }
+      end
+    elsif collection.kind_of?(Hash)
+      collection = collection.to_a
+    end
+
+    if blank_option
+      collection.insert(0,["null", t("views.select_boxes.no_value")])
+    end
+
+    collection.map! { |option| [option[0].to_s, option[1].to_s] }
+    collection
+
+  end
+
+  def select_component_get_selected_value(options, type=:input)
+
+    input_value = if options[:selected]
+      options[:selected]
+    elsif options[:name]
+      get_value_for_field_name(options)
+    end
+
+    if type == :input
+      input_value
+    else
+      if options[:collection].blank? && !get_value_for_field_name(options)
+        return get_value_for_field_name(options, from_params: true)
+      end
+      prepare_select_collection(options[:collection]).to_h[input_value]
+    end
+
+  end
+
+  def get_value_for_field_name(options, from_params: false)
+
+    @model_array_fields_counter ||= {}
+
+    if options[:name] && options[:name].include?("[")
+      names       = get_field_names_chain_from_nested_field_param_and_model(options)
+      model_name  = names.shift
+
+      if options[:model] && !from_params
+        field_name = options[:model_field_name] || options[:attr_name]
+        if field_name.blank?
+          return nil
+        else
+          if options[:nested_field]
+            model = get_target_model(names, options)
+            model.send(field_name) if model
+          else
+            field = options[:model].send(names.shift)
+            names.each do |n|
+              return nil if n.nil? || field.nil?
+              # This deals with fields that are arrays, for example quiz_question[answers][en][]
+              # In case field name ends with [] (empty string in `n`), we start counting how many fields
+              # with such a name exist and pull values from the model's array stored in that field.
+              if n.to_s == ""
+                @model_array_fields_counter[options[:name]] ||= 0
+                field = field[@model_array_fields_counter[options[:name]]]
+                @model_array_fields_counter[options[:name]] = @model_array_fields_counter[options[:name]] + 1
+              else
+                field = field[n]
+              end
+            end
+            return field
+          end
+        end
+      else
+        field_name = options[:attr_name]
+        value = params[options[:model_name]]
+        names.each do |fn|
+          value = if fn.kind_of?(Array) && value
+            m = value["#{fn[0]}_attributes"]
+            m[options[:field_counter]] if m
+          else
+            value["#{fn}_attributes"] if value
+          end
+        end
+        return value[field_name] if value
+      end
+    else
+      params[options[:name]]
+    end
+  end
+
+  def get_error_for_field_name(options)
+    names      = get_field_names_chain_from_nested_field_param_and_model(options)
+    model_name = names.shift
+    field_name = options[:attr_name]
+    return unless field_name
+
+    if !options[:model].blank? && model = get_target_model(names, options)
+      model.errors[field_name]
+    end
+  end
+
+  def get_field_names_chain_from_nested_field_param_and_model(options)
+    result = [options[:model].class.to_s.underscore]
+
+    # associated model
+    if assoc = options[:nested_field]
+      assoc.each do |a|
+        if a[1] == :has_one
+          result << a[0]
+        else
+          result << [a[0], a[2]]
+        end
+      end
+
+    # serialized hash
+    elsif options[:name]
+      result = []
+      options[:name].split("[").map { |n| n.chomp("]") }.each do |n|
+        n = if n =~ /\A\d+\Z/
+          n.to_i
+        else
+          n.to_sym
+        end
+        result << n
+      end
+    end
+    result
+  end
+
+  def get_target_model(names, options)
+    model = options[:model]
+    return model unless options[:nested_field]
+
+    names.each_with_index do |fn,i|
+      return nil if model.nil?
+      model = if fn.kind_of?(Array)
+        collection = model.send(fn[0])
+        if fn[1]
+          collection.select { |m| fn[1] == m.id }.first
+        else
+          collection[options[:field_counter]]
+        end
+      else
+        model.send(fn)
+      end
+    end
+    model
+  end
+
+end

data/app/helpers/webface_form.rb

@@ -0,0 +1,161 @@
+class WebfaceForm
+
+  OPTION_ATTRS = [:tabindex, :label, :suffix, :selected, :hint, :collection, :allow_custom_value, :fetch_url, :query_param_name, :disabled, :nested_field, :serialized_hash, :model_field_name, :model_name, :radio_options_id, :popup_hint, :has_blank]
+
+  class NoSuchFormFieldType < Exception;end
+
+  def initialize(model, view_context)
+    @model         = model
+    @view_context  = view_context
+    @field_counter = {}
+  end
+
+  def method_missing(m, *args)
+
+    attrs   = {}
+    options = {}
+    if args.last.kind_of?(Hash)
+      attrs   = args.last
+      options = separate_option_attrs(attrs)
+    end
+    field_type = m
+
+    unless self.class.private_method_defined?("_#{field_type}")
+      raise NoSuchFormFieldType, "Field type `#{field_type}` not supported"
+    end
+
+    field_name = if args.first.blank? || args.first.to_s =~ /!\Z/
+      args.first.to_s.sub("!", "")
+    else
+      "#{@model.class.to_s.underscore}[#{args.first}]"
+    end
+
+    if options[:nested_field]
+      field_name = modify_name_for_nested_field(field_name, options[:nested_field])
+    elsif args.first && args.first.to_s.include?("[") && options[:nested_field].nil?
+      field_name = modify_name_for_serialized_field(field_name)
+    end
+
+    if @field_counter[field_name]
+      @field_counter[field_name] += 1
+    else
+      @field_counter[field_name] = 0
+    end
+    options[:field_counter] = @field_counter[field_name]
+
+    options[:radio_options_id] = options[:name] if options[:name]
+
+    options.merge!({ name: field_name, attr_name: args.first, model: @model, model_name: self.model_name})
+    attrs.delete_if { |k,v| OPTION_ATTRS.include?(k) }
+    attrs.merge!({ options: options })
+
+    if attrs[:options][:label].nil?
+      attrs[:options][:label] = I18n.t("models.#{field_name_for_i18n(field_name)}")
+    end
+
+    self.send("_#{field_type}", attrs)
+  end
+
+  def model_name
+    if @model
+      @model.class.to_s.underscore
+    else
+      options[:name].split("[").first
+    end
+  end
+
+  private
+
+    def _text(attrs)
+      @view_context.component :text_form_field, attrs
+    end
+
+    def _password(attrs)
+      @view_context.component :password_form_field, attrs
+    end
+
+    def _hidden(attrs)
+      @view_context.component :hidden_form_field, attrs
+    end
+
+    def _numeric(attrs)
+      @view_context.component :numeric_form_field, attrs
+    end
+
+    def _textarea(attrs)
+      @view_context.component :textarea_form_field, attrs
+    end
+
+    def _checkbox(attrs)
+      @view_context.component :checkbox, attrs
+    end
+
+    def _select(attrs)
+      @view_context.component :select, attrs
+    end
+
+    def _editable_select(attrs)
+      @view_context.component :editable_select, attrs
+    end
+
+    def _radio(attrs)
+      @view_context.component :radio, attrs
+    end
+
+    def _submit(attrs)
+      attrs[:data] ||= {}
+      attrs[:data][:prevent_native_click_event] = "false"
+      @view_context.component :button, attrs.merge({options: { type: :submit}})
+    end
+
+    def separate_option_attrs(attrs)
+      option_attrs = {}
+      if attrs.kind_of?(Hash)
+        OPTION_ATTRS.each do |o|
+          option_attrs[o] = attrs[o] if !attrs[o].nil?
+        end
+      end
+      option_attrs
+    end
+
+    def modify_name_for_nested_field(name, association_name)
+      if association_name.kind_of?(Array)
+        association_name.each do |a|
+          name = send("modify_name_for_nested_#{a[1]}", name, a[0])
+        end
+        return name
+      else
+        modify_name_for_nested_has_many(name, association_name)
+      end
+    end
+
+    def modify_name_for_serialized_field(field_name)
+      model,remainder = field_name.split("[",2)
+      remainder.chomp!("]")
+      field_name,remainder = remainder.split("[",2)
+      "#{model}[#{field_name}][#{remainder}"
+    end
+
+    def modify_name_for_nested_has_one(name, nested_has_one_name)
+      # name   == model[attribute]
+      # result == model[association][attribute]
+      model_name        = name.scan(/\A.*?\[/)[0].sub("[", "")
+      field_names       = name.scan(/\[.*?\]/)
+      actual_field_name = field_names.pop
+      "#{model_name}#{field_names.join("")}[#{nested_has_one_name}_attributes]#{actual_field_name}"
+    end
+
+    def modify_name_for_nested_has_many(name, nested_has_many_name)
+      # name   == model[attribute]
+      # result == model[association][][attribute]
+      model_name        = name.scan(/\A.*?\[/)[0].sub("[", "")
+      field_names       = name.scan(/\[.*?\]/)
+      actual_field_name = field_names.pop
+      "#{model_name}#{field_names.join("")}[#{nested_has_many_name}_attributes][]#{actual_field_name}"
+    end
+
+    def field_name_for_i18n(fn)
+      fn = fn.split("[").map { |n| n.sub("]", "") }.join(".")
+    end
+
+end