webface_rails 0.1.6

data/lib/generators/templates/test_utils.js

@@ -0,0 +1,6 @@
+export async function fetch_dom(path) {
+  var response = await fetch('http://localhost:8080/' + path);
+  var body;
+  await response.text().then((t) => body = t);
+  return new DOMParser().parseFromString(body, "text/html").documentElement.querySelector("body");
+}

data/lib/generators/templates/webface.test.js

@@ -0,0 +1,2 @@
+// Here you import the *.test.js files, path is relative to the current dir
+import "./components/my_component.test.js";

data/lib/generators/templates/webface_init.js

@@ -0,0 +1,10 @@
+import { Logmaster } from './webface_source/logmaster.js'
+import { TestAnimator  } from './test_animator.js' // required to make some unit tests dependent on animation pass
+
+window.webface = {
+  "component_classes" : {},
+  "logger"            : new Logmaster({test_env: true}),
+  "substitute_classes": { "Animator": TestAnimator }
+};
+
+window.webface.logmaster_print_spy = chai.spy.on(window.webface.logger, "_print");

data/lib/generators/templates/webface_test_server.js

@@ -0,0 +1,68 @@
+const express  = require('express')
+var bodyParser = require('body-parser');
+const fs       = require('fs');
+const app      = express();
+app.use(bodyParser.urlencoded({ extended: true }));
+app.use(bodyParser.json());
+app.set('view engine', 'pug')
+
+// This is the main page where all tests are loaded and mocha is plugged in
+app.get("/", function (req, res) {
+  var file = req.query.file;
+  if(file == "" || file == null)
+    file = "webface.test.js";
+  else if(file.startsWith("test"))
+    file = file.replace("test", "");
+
+  fs.readFile(`mocha.html`, 'utf8', function(err, contents) {
+    res.render(__dirname + "/mocha.pug", { file: file });
+  });
+})
+
+// These ones are needed in case you need to test an ajax_request
+app.post("/ajax_test", function (req, res, next) {
+  res.type("application/json");
+  res.end(JSON.stringify(req.body));
+});
+app.get("/ajax_test", function (req, res, next) {
+  res.type("application/json");
+  res.end(JSON.stringify(req.query));
+});
+
+
+// This one is in charge of loading additional files required for the tests, such as: js, css, html, images.
+app.get(/.+/, function (req, res) {
+  var fn = req.path.substring(1);
+  if(fn.endsWith("/")) fn = fn.slice(0, -1);
+
+  var fn_splitted = fn.split("/");
+  var fn_last_part = fn_splitted[fn_splitted.length - 1]
+
+
+  if(/^[^.]+$/.test(fn_last_part))
+    fn = fn + "/index.html";
+
+  fn = __dirname + "/" + fn;
+
+  if(fs.existsSync(fn)) {
+    fs.readFile(fn, 'utf8', function(err, contents) {
+      if(fn.endsWith(".js"))
+        res.type("application/javascript");
+      else if(fn.endsWith(".svg")) {
+        res.type("image/svg+xml");
+      }
+      else if(fn.endsWith(".css"))
+        res.type("text/css");
+      else
+        res.type("text/html");
+      res.end(contents);
+    });
+  }
+  else {
+    res.status(404).send("Not found");
+  }
+
+
+})
+
+app.listen(8080, () => console.log('Test server for Webface.js running on port 8080.'))

data/lib/generators/webface_generator.rb

@@ -0,0 +1,81 @@
+class WebfaceGenerator < Rails::Generators::Base
+
+  source_root File.expand_path('templates', __dir__)
+  class_option :root_path, type: :string
+
+  def add_webface
+    @root_path = options["root_path"].present? ? options["root_path"] : Rails.root
+
+    # We'll later change this to fetching webface.js as a node_module, but not now.
+    gitmodules = File.readlines("#{@root_path}/.gitmodules") if File.file?("#{@root_path}/.gitmodules")
+
+    if gitmodules.nil? || !gitmodules.join("\n").include?("webface.js.git")
+      `rm -rf #{@root_path}/.git/modules/app/assets/javascripts/webface.js`
+      `cd #{@root_path}/app/assets/javascripts/ && git submodule add git@gitlab.com:hodl/webface.js.git`
+      gitmodules = File.readlines("#{@root_path}/.gitmodules") if File.file?("#{@root_path}/.gitmodules")
+    end
+
+    gitmodules.each do |line|
+      if line.include?("webface") && line.include?("path =")
+        @webface_path = line.strip.sub(/\Apath = /, "")
+      end
+    end
+    puts "Webface path is #{@webface_path}"
+  end
+
+  def create_webface_unit_test_dir
+    `mkdir -p #{@root_path}/spec/webface/`
+    `mkdir -p #{@root_path}/spec/webface/components/`
+  end
+
+  def copy_unit_test_server
+    copy_file "webface_test_server.js", "spec/webface/test_server.js"
+    copy_file "run_webface_test", "spec/webface/run_test"
+    `chmod +x #{@root_path}/spec/webface/run_test`
+    copy_file "mocha.css", "spec/webface/mocha.css"
+    copy_file "mocha.pug", "spec/webface/mocha.pug"
+    copy_file "test_utils.js", "spec/webface/test_utils.js"
+    copy_file "webface.test.js", "spec/webface/webface.test.js"
+    copy_file "webface_init.js", "spec/webface/webface_init.js"
+    copy_file "test_animator.js", "spec/webface/test_animator.js"
+    copy_file "my_component.test.js", "spec/webface/components/my_component.test.js"
+
+    copy_file "application.js", "app/assets/javascripts/application.js"
+    gsub_file "app/assets/javascripts/application.js", "path_to_webface", @webface_path.sub(/\A.*app\/assets\/javascripts\//, "") + "/lib"
+  end
+
+  def add_node_modules_to_gitignore
+    `echo "spec/webface/node_modules"           >> #{@root_path}/.gitignore` unless File.read("#{@root_path}/.gitignore").include?("spec/webface/node_modules")
+    `echo "app/assets/javascripts/node_modules" >> #{@root_path}/.gitignore` unless File.read("#{@root_path}/.gitignore").include?("app/assets/javascripts/node_modules")
+  end
+
+  def copy_package_json
+    copy_file "#{@root_path}/#{@webface_path}/package.json", "app/assets/javascripts/package.json"
+    copy_file "#{@root_path}/#{@webface_path}/package-lock.json", "app/assets/javascripts/package-lock.json"
+  end
+
+  def create_symlinks
+    create_symlink("#{@root_path}/app/assets/javascripts", "#{@root_path}/spec/webface/source")
+    create_symlink("#{@root_path}/app/assets/javascripts/node_modules", "#{@root_path}/spec/webface/node_modules")
+    create_symlink("#{@root_path}/#{@webface_path}", "#{@root_path}/spec/webface/webface_source")
+    create_symlink "#{@root_path}/app/assets/javascripts/package.json", "#{@root_path}/spec/webface/package.json"
+    create_symlink "#{@root_path}/app/assets/javascripts/package-lock.json", "#{@root_path}/spec/webface/package-lock.json"
+  end
+
+  def install_node_modules
+    puts `cd #{@root_path}/app/assets/javascripts && npm i`
+  end
+
+  private
+
+    def create_symlink(from, to)
+      files = "#{from} #{to}"
+      unless File.exist?(to)
+        puts "   Symlinking ".colorize(:green) + from + " -> " + to
+        `ln -s #{files}`
+      else
+        puts "   Symlink already exists ".colorize(:light_blue) + to
+      end
+    end
+
+end

data/lib/tasks/webface_rails_tasks.rake

@@ -0,0 +1,3 @@
+desc "Run Webface javascripts unit tests"
+task :webface_spec do
+end

data/lib/webface_rails.rb

@@ -0,0 +1,11 @@
+require_relative "../app/helpers/webface_component_helper"
+require_relative "../app/helpers/webface_form"
+
+module WebfaceRails
+
+  if defined?(Rails)
+    class Engine < Rails::Engine
+    end
+  end
+
+end

data/lib/webface_rails/version.rb

@@ -0,0 +1,3 @@
+module WebfaceRails
+  VERSION = '0.1.6'
+end

data/spec/helpers/webface_component_helper_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'active_support/all'
+
+# Dummy class
+class Offer;end
+
+RSpec.describe WebfaceComponentHelper do
+
+  before(:each) do
+    @model                 = double("model")
+    @model_with_collection = double("model with collection")
+    @target_model          = double("target_model")
+    @dummy                 = double("dummy")
+    allow(@dummy).to        receive(:id).and_return(nil)
+    allow(@target_model).to receive(:id).and_return(5)
+    @options = { name: "model[association1][association2][][field_name]", field_counter: 5, model_name: "model", nested_field: [[:association1, :has_one], [:association2, :has_many]], attr_name: "field_name", model: @model }
+  end
+
+  include WebfaceComponentHelper
+
+  # This is a dummy method so we don't need to import I18n from rails
+  def t(key)
+    key.include?("no_value") ? "[no value]" : key
+  end
+
+  it "breaks down associations chain used in field name into an array" do
+    field_1 = { model: Offer.new, nested_field: [[:association1, :has_one], [:association2, :has_many, 1]] }
+    field_2 = { model: Offer.new, nested_field: [[:association1, :has_many, 1], [:association2, :has_many, 2]] }
+    field_3 = { model: Offer.new, nested_field: [[:association1, :has_many], [:association2, :has_many]] }
+    field_4 = { model: Offer.new, nested_field: [[:association1, :has_many], [:association2, :has_one]] }
+    expect(get_field_names_chain_from_nested_field_param_and_model(field_1)).to eq(
+      ["offer", :association1, [:association2, 1]]
+    )
+    expect(get_field_names_chain_from_nested_field_param_and_model(field_2)).to eq(
+      ["offer", [:association1,1], [:association2, 2]]
+    )
+    expect(get_field_names_chain_from_nested_field_param_and_model(field_3)).to eq(
+      ["offer", [:association1,nil], [:association2, nil]]
+    )
+    expect(get_field_names_chain_from_nested_field_param_and_model(field_4)).to eq(
+      ["offer", [:association1,nil], :association2]
+    )
+  end
+
+  describe "getting value from a model" do
+
+    it "gets value for the field from the model when model is not saved" do
+      allow(@target_model).to receive(:id).and_return(nil)
+      expect(@target_model).to receive(:field_name).and_return("value")
+      expect(@model_with_collection).to receive(:association2).and_return([@dummy,@dummy,@dummy,@dummy,@dummy,@target_model])
+      expect(@model).to receive(:association1).and_return(@model_with_collection)
+      expect(get_value_for_field_name(@options)).to eq("value")
+    end
+
+    it "uses a different field_name for the model if specified" do
+      allow(@target_model).to receive(:id).and_return(nil)
+      expect(@target_model).to receive(:attr_name).and_return("value")
+      expect(@model_with_collection).to receive(:association2).and_return([@dummy,@dummy,@dummy,@dummy,@dummy,@target_model])
+      expect(@model).to receive(:association1).and_return(@model_with_collection)
+      expect(get_value_for_field_name(@options.merge(model_field_name: "attr_name"))).to eq("value")
+    end
+
+    it "gets value for an existing model (with id) in a has_many association" do
+      @options[:nested_field] = [[:association1, :has_one], [:association2, :has_many, 5]]
+      allow(@target_model).to receive(:id).and_return(5)
+      expect(@target_model).to receive(:attr_name).and_return("value")
+      expect(@model_with_collection).to receive(:association2).and_return([@dummy,@target_model])
+      expect(@model).to receive(:association1).and_return(@model_with_collection)
+      expect(get_value_for_field_name(@options.merge(model_field_name: "attr_name"))).to eq("value")
+    end
+
+  end
+
+  describe "getting value from a serialized Hash stored in a field" do
+    
+    it "gets value from a single level serialized hash" do
+      allow(@model).to receive(:serialized_field).and_return({ hello: "world" })
+      expect(get_value_for_field_name({name: "model[serialized_field][hello]", model_name: "model", attr_name: "serialized_field", model: @model })).to eq("world")
+    end
+
+    it "gets value from a multiple level serialized hash" do
+      allow(@model).to receive(:serialized_field).and_return({ hello: { hi: "world" }})
+      expect(get_value_for_field_name({name: "model[serialized_field][hello][hi]", model_name: "model", attr_name: "serialized_field", model: @model })).to eq("world")
+    end
+
+    it "gets value from a multiple level serialized hash with arrays" do
+      allow(@model).to receive(:serialized_field).and_return({ hello: { hi: ["whole", "wide", "world"] }})
+      expect(get_value_for_field_name({name: "model[serialized_field][hello][hi][2]", model_name: "model", attr_name: "serialized_field", model: @model })).to eq("world")
+    end
+
+  end
+
+  it "gets value for the field from params" do
+    @options[:model] = nil
+    expect(self).to receive(:params).and_return(HashWithIndifferentAccess.new({model: { association1_attributes: { association2_attributes: [0,0,0,0,0, { "field_name" => "value"}]}}}))
+    expect(get_value_for_field_name(@options)).to eq("value")
+  end
+
+  it "gets error message for the field from the model" do
+    @options[:nested_field] = [[:association1, :has_one], [:association2, :has_many, 5]]
+    expect(@target_model).to receive(:errors).and_return(HashWithIndifferentAccess.new({ field_name: "error message"}))
+    allow(@target_model).to receive(:id).and_return(5)
+    expect(@model_with_collection).to receive(:association2).and_return([@dummy,@target_model])
+    expect(@model).to receive(:association1).and_return(@model_with_collection)
+    expect(get_error_for_field_name(@options)).to eq("error message")
+  end
+
+  describe "SelectComponent helpers" do
+
+    it "prepares a collection of field names & values out of Hash" do
+      c = { key1: "value1", key2: "value2", key3: "value3" }
+      expect(prepare_select_collection(c)).to eq([["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
+    end
+
+    it "prepares a collection of field names & values out of Array" do
+      c = ["value1", "value2", "value3"]
+      expect(prepare_select_collection(c)).to eq([["value1", "value1"], ["value2", "value2"], ["value3", "value3"]])
+    end
+
+    it "prepares a collection of field names and includes an blank value first" do
+      c = ["value1", "value2", "value3"]
+      expect(prepare_select_collection(c, selected: "value1", blank_option: true)).to eq([["null", "[no value]"], ["value1", "value1"], ["value2", "value2"], ["value3", "value3"]])
+    end
+
+    it "returns selected value for the SelectComponent field" do
+      c = { key1: "value1", key2: "value2", key3: "value3" }
+      options = { selected: "key1", collection: c }
+      expect(select_component_get_selected_value(options, :display)).to eq("value1")
+    end
+
+  end
+
+end

data/spec/helpers/webface_form_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+# Dummy class
+class Offer;end
+
+RSpec.describe WebfaceForm do
+
+  before(:each) do
+    @component_form = WebfaceForm.new(Offer.new, nil)
+  end
+
+  it "modifies field name for nested has_one association" do
+    field_name = "offer[payment_method_type]"
+    assoc_name = :payment_method
+    expect(@component_form.send(:modify_name_for_nested_has_one, field_name, assoc_name)).to eq(
+      "offer[payment_method_attributes][payment_method_type]"
+    )
+    field_name = "offer[payment_method_instructions_attributes][][name]"
+    expect(@component_form.send(:modify_name_for_nested_has_one, field_name, assoc_name)).to eq(
+      "offer[payment_method_instructions_attributes][][payment_method_attributes][name]"
+    )
+  end
+
+  it "modifies field name for nested has_many association" do
+    field_name = "offer[instructions]"
+    assoc_name = :payment_method_instructions
+    expect(@component_form.send(:modify_name_for_nested_has_many, field_name, assoc_name)).to eq(
+      "offer[payment_method_instructions_attributes][][instructions]"
+    )
+  end
+
+  it "modifies field name for multiple levels of associations" do
+    field_name = "offer[name]"
+    assoc_name = [[:payment_method_instructions, :has_many], [:payment_method, :has_one]]
+    expect(@component_form.send(:modify_name_for_nested_field, field_name, assoc_name)).to eq(
+      "offer[payment_method_instructions_attributes][][payment_method_attributes][name]"
+    )
+  end
+
+  it "modifies field name for serialized field hash" do
+    expect(@component_form.send(:modify_name_for_serialized_field, "offer[serialized_field[hello][]]")).to eq(
+      "offer[serialized_field][hello][]"
+    )
+
+    expect(@component_form.send(:modify_name_for_serialized_field, "offer[serialized_field[hello]]")).to eq(
+      "offer[serialized_field][hello]"
+    )
+
+    expect(@component_form.send(:modify_name_for_serialized_field, "offer[serialized_field[hello][hi]]")).to eq(
+      "offer[serialized_field][hello][hi]"
+    )
+
+    expect(@component_form.send(:modify_name_for_serialized_field, "quiz_question[question[ru]]")).to eq(
+      "quiz_question[question][ru]"
+    )
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "bundler/setup"
+Bundler.setup
+require "webface_rails"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: webface_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- Roman Snitko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides view helpers for creating components, standard component views
+  and css, form builder and a unit test server
+email:
+- roman.snitko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/webface_error_report_controller.rb
+- app/helpers/webface_component_helper.rb
+- app/helpers/webface_form.rb
+- app/views/webface_component_templates/_button.html.haml
+- app/views/webface_component_templates/_dialog_window.html.haml
+- app/views/webface_component_templates/_modal_window.html.haml
+- app/views/webface_component_templates/_simple_notification.html.haml
+- app/views/webface_components/_button.html.haml
+- app/views/webface_components/_checkbox.html.haml
+- app/views/webface_components/_editable_select.html.haml
+- app/views/webface_components/_field_hints.html.haml
+- app/views/webface_components/_hidden_form_field.html.haml
+- app/views/webface_components/_hint.html.haml
+- app/views/webface_components/_hint_trigger.html.haml
+- app/views/webface_components/_numeric_form_field.html.haml
+- app/views/webface_components/_password_form_field.html.haml
+- app/views/webface_components/_post_button_link.html.haml
+- app/views/webface_components/_radio.html.haml
+- app/views/webface_components/_select.html.haml
+- app/views/webface_components/_text_form_field.html.haml
+- app/views/webface_components/_text_form_field_with_validation.html.haml
+- app/views/webface_components/_textarea_form_field.html.haml
+- app/views/webface_components/shared/_editable_select_base.html.haml
+- lib/generators/templates/application.js
+- lib/generators/templates/mocha.css
+- lib/generators/templates/mocha.pug
+- lib/generators/templates/my_component.test.js
+- lib/generators/templates/run_webface_test
+- lib/generators/templates/test_animator.js
+- lib/generators/templates/test_utils.js
+- lib/generators/templates/webface.test.js
+- lib/generators/templates/webface_init.js
+- lib/generators/templates/webface_test_server.js
+- lib/generators/webface_generator.rb
+- lib/tasks/webface_rails_tasks.rake
+- lib/webface_rails.rb
+- lib/webface_rails/version.rb
+- spec/helpers/webface_component_helper_spec.rb
+- spec/helpers/webface_form_spec.rb
+- spec/spec_helper.rb
+homepage: https://webfacejs.org
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Webface.js integration for Ruby On Rails
+test_files:
+- spec/helpers/webface_form_spec.rb
+- spec/helpers/webface_component_helper_spec.rb
+- spec/spec_helper.rb