opal-ferro 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f56567922f613ccb4b5dc4bf3dae7ea52c67f24b
+  data.tar.gz: 9214aa5989306aacd55e435d43161ba60ac26a30
+SHA512:
+  metadata.gz: 66c1f60432258923680daddeef451abecfae6cf9b77d94877f088cd574f8d59385c4210cbe073614e1164b65c0e676c64de8646d6f1d9c9ce3069a4b454d54a1
+  data.tar.gz: d82fc2be389ff2954bf55f086ffc1f3bef427017c6dd534d0d35b63425dd702673617290a8339f6fe874367a5aa84b4142ffeb2d49f84c08707a7ae20aa6a8f2

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.ruby-version

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.3
+before_install: gem install bundler -v 1.16.1

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at info@edwhs.nl. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in opal-ferro.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-2018 Ivo Herweijer
+
+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,43 @@
+# Opal-Ferro
+Ferro is a small Ruby library on top of [Opal](http://opalrb.com/)
+that enables an object-oriented programming style for creating code
+that runs in the webbrowser.
+No more distractions like HTML and searching for DOM elements,
+just beautiful and simple Ruby code. Front-End-Ruby-ROcks!
+
+## Installation
+Add this line to your application's Gemfile:
+
+``` ruby
+gem 'opal-ferro'
+```
+
+And then execute:
+
+    bundle
+
+Or install it yourself:
+
+    gem install opal-ferro
+
+## Usage
+Please see the [Ferro website](https://easydatawarehousing.github.io/ferro/)
+for background information and examples.
+
+## Development
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`
+and then run `bundle exec rake release`, which will create a git tag for
+the version, push git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/easydatawarehousing/opal-ferro.
+This project is intended to be a safe, welcoming space for collaboration
+and contributors are expected to adhere to the
+[Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+The gem is available as open source under the terms of the MIT License.
+See LICENSE.txt

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/lib/opal/ferro.rb

@@ -0,0 +1 @@
+require 'opal-ferro'

data/lib/opal-ferro/version.rb

@@ -0,0 +1,5 @@
+module Opal
+  module Ferro
+    VERSION = "0.10.0"
+  end
+end

data/lib/opal-ferro.rb

@@ -0,0 +1,3 @@
+require 'opal'
+require 'opal-ferro/version'
+Opal.append_path File.expand_path('../../opal', __FILE__)

data/opal/opal-ferro/ferro_base_elements.js.rb

@@ -0,0 +1,158 @@
+class FerroElementComponent < FerroElement
+  def component
+    self
+  end
+end
+
+# Semantical elements
+class FerroElementHeader < FerroElementComponent
+  def _before_create
+    @domtype = :header
+  end
+end
+
+class FerroElementNavigation < FerroElementComponent
+  def _before_create
+    @domtype = :nav
+  end
+end
+
+class FerroElementSection < FerroElementComponent
+  def _before_create
+    @domtype = :section
+  end
+end
+
+class FerroElementArticle < FerroElementComponent
+  def _before_create
+    @domtype = :article
+  end
+end
+
+class FerroElementAside < FerroElementComponent
+  def _before_create
+    @domtype = :aside
+  end
+end
+
+class FerroElementFooter < FerroElementComponent
+  def _before_create
+    @domtype = :footer
+  end
+end
+
+FerroElementBlock = FerroElement
+
+# Inline elements
+class FerroElementText < FerroElement
+  def _before_create
+    @size    = option_replace :size, 0
+    @domtype = @size == 0 ? :p : "h#{@size}"
+  end
+end
+
+class FerroElementList < FerroElement
+  def _before_create
+    @domtype = @options.has_key?(:type) ? :ol : :ul
+    @items   = []
+    @id      = FerroSequence.new 'list_'
+  end
+
+  def add_item(element_class, options = {})
+    @items << add_child(@id.next, element_class, options).sym
+  end
+
+  def item_count
+    @items.length
+  end
+
+  def first_item
+    @children[@items.first]
+  end
+
+  def last_item
+    @children[@items.last]
+  end
+
+  def unlist_item(sym)
+    @items.delete_if { |item| item == sym }
+  end
+end
+
+class FerroElementListItem < FerroElement
+  def _before_create
+    @domtype = :li
+  end
+
+  def destroy
+    super
+    parent.unlist_item(@sym)
+  end
+end
+
+class FerroElementAnchor < FerroElement
+  def _before_create
+    @domtype = :a
+    @href = @options[:href]
+  end
+
+  def _after_create
+    `#{@element}.addEventListener("click",function(e){e.preventDefault();history.pushState(null,null,#{@href});#{clicked};document.activeElement.blur();})`
+  end
+
+  def update_href(value)
+    @href = value
+    set_attribute('href', @href)
+  end
+
+  def clicked
+    router.navigated
+  end
+end
+
+class FerroElementExternalLink < FerroElement
+  def _before_create
+    @domtype = :a
+    @options[:target] ||= '_blank'
+  end
+end
+
+# Miscellaneous elements
+class FerroElementImage < FerroElement
+
+  # Todo use:
+  # <figure>
+  # <figcaption>
+  
+  def _before_create
+    @domtype = :img
+    @options[:alt] ||= @options[:src]
+  end
+end
+
+class FerroElementCanvas < FerroElement
+  def _before_create
+    @domtype = :canvas
+  end
+end
+
+class FerroElementScript < FerroElement
+  def _before_create
+    @domtype = :script
+    @run     = option_replace :invoke, true
+  end
+
+  def _after_create
+    load
+    invoke if @run
+  end
+
+  def load;end
+  def invoke;end
+end
+
+class FerroElementVar < FerroElement
+  def _before_create
+    @domtype = option_replace :domtype, :div
+  end
+end

data/opal/opal-ferro/ferro_components.js.rb

@@ -0,0 +1,92 @@
+# A component with a text entry field and submit button
+class FerroFormSearch < FerroForm
+  
+  def _before_create
+    @button_text = option_replace :button_text, ' '
+    @placeholder = option_replace :placeholder, ' Search...'
+  end
+
+  def cascade
+    add_child :entry,  FerroFormSearchInput,  { placeholder: @placeholder }
+    add_child :submit, FerroFormSearchSubmit, { content: @button_text }
+  end
+
+  def do_submit
+    value = entry.value.strip
+    submitted(value) if !value.empty?
+
+    entry.toggle_state :search_input_open
+    submit.toggle_state :search_submit_open
+
+    entry.value = nil
+    entry.set_focus if entry.state_active?(:search_input_open)
+  end
+
+  def submitted(value);end
+end
+
+class FerroFormSearchInput < FerroFormInput
+
+  def _after_create
+    add_state :search_input_open
+    super
+  end
+
+  def entered
+    parent.do_submit
+  end
+end
+
+class FerroFormSearchSubmit < FerroFormButton
+
+  def _after_create
+    add_state :search_submit_open
+    super
+  end
+
+  def clicked
+    parent.do_submit
+  end
+end
+
+# A simple pull-down menu
+# @option[items]: a list of classes
+class FerroPullDown < FerroElementBlock
+
+  def _before_create
+    @title_text = option_replace :title, '='
+    @items      = option_replace :items, []
+    super
+  end
+
+  def _after_create
+    add_state :pull_down_open
+    super
+  end
+
+  def cascade
+    add_child :title, FerroPullDownTitle, { content: @title_text }
+    add_child :items, FerroPullDownItems, { items:   @items }
+  end
+end
+
+class FerroPullDownTitle < FerroFormBlock
+  def clicked
+    parent.toggle_state :pull_down_open
+  end
+end
+
+class FerroPullDownItems < FerroElementBlock
+
+  def _before_create
+    @id       = FerroSequence.new 'pdi_'
+    @itemlist = option_replace :items, []
+    super
+  end
+
+  def cascade
+    @items = @itemlist.map do |item|
+      add_child @id.next, item
+    end
+  end
+end

data/opal/opal-ferro/ferro_document.js.rb

@@ -0,0 +1,36 @@
+class FerroDocument
+
+  include FerroElementary
+
+  def initialize
+    @children = {}
+    creation
+    # router.navigated
+  end
+
+  def parent
+    self
+  end
+
+  def element
+    @factory.body
+  end
+
+  def factory
+    @factory ||= FerroFactory.new
+  end
+
+  def root
+    self
+  end
+
+  def component
+    self
+  end
+
+  def router
+    @router ||= FerroRouter.new(method(:page404))
+  end
+
+  def page404(pathname);end
+end

data/opal/opal-ferro/ferro_element.js.rb

@@ -0,0 +1,110 @@
+class FerroElement
+
+  include FerroElementary
+  
+  attr_reader :parent, :sym, :children, :element, :domtype
+
+  def initialize(parent, sym, options = {})
+    @parent   = parent
+    @sym      = sym
+    @children = {}
+    @element  = nil
+    @domtype  = :div
+    @states   = {}
+    @options  = options
+
+    creation
+  end
+
+  def factory
+    @parent.factory
+  end
+
+  def root
+    @parent.root
+  end
+
+  def component
+    @parent.component
+  end
+
+  def router
+    @parent.router
+  end
+
+  def option_replace(key, default = nil)
+    value = @options[key] || default
+    @options.delete(key) if @options.has_key?(key)
+    value
+  end
+
+  # Store element states: adds/removes css classes
+  def add_states(states)
+    states.each do |state|
+      add_state(state)
+    end
+  end
+
+  def add_state(state, value = false)
+    @states[state] = [factory.dasherize(state), value]
+    classify_state @states[state]
+  end
+
+  # active: true, false, nil
+  def update_state(state, active)
+    if !active.nil?
+      @states.each do |s, v|
+        v[1] = active if s == state
+        classify_state v
+      end
+    end
+  end
+
+  def toggle_state(state)
+    @states.select { |s, _| s == state }.each do |s, v|
+      v[1] = !v[1]
+      classify_state v
+    end
+  end
+
+  def classify_state(state)
+    if state[1]
+      `#{element}.classList.add(#{state[0]})`
+    else
+      `#{element}.classList.remove(#{state[0]})`
+    end
+  end
+
+  def state_active?(state)
+    @states[state][1]
+  end
+
+  def value
+    `#{@element}.innerHTML`
+  end
+
+  def get_text
+    `#{@element}.textContent`
+  end
+
+  def set_text(value)
+    # https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent
+    `#{@element}.textContent = #{value}`
+  end
+
+  def html(raw_html)
+    `#{@element}.innerHTML = #{raw_html}`
+  end
+
+  def set_attribute(name, value)
+    if name == 'scrollTop'
+      `#{element}.scrollTop=#{value}`
+    else
+      `#{element}.setAttribute(#{name}, #{value})`
+    end
+  end
+
+  def remove_attribute(name)
+    `#{element}.removeAttribute(#{name})`
+  end
+end

data/opal/opal-ferro/ferro_elementary.js.rb

@@ -0,0 +1,79 @@
+module FerroElementary
+
+  RESERVED_NAMES = %i[
+    initialize factory root router page404
+    creation _before_create before_create create _after_create
+    after_create style _stylize cascade
+    add_child forget_children remove_child method_missing destroy
+    value set_text html parent children element domtype options
+    add_states add_state update_state toggle_state state_active
+  ]
+
+  def creation
+    _before_create
+    before_create
+    create
+    _after_create
+    after_create
+    _stylize
+    cascade
+  end
+  
+  def _before_create;end
+  def before_create;end
+
+  def create
+    @element = factory.create_element(self, @domtype, @parent, @options) if @domtype 
+  end
+
+  def _after_create;end
+  def after_create;end
+
+  def style;end
+
+  def _stylize
+    styles = style
+
+    if styles.class == Hash
+      set_attribute(
+        'style',
+        styles.map { |k, v| "#{k}:#{v};" }.join
+      )
+    end
+  end
+
+  def cascade;end
+
+  def add_child(name, element_class, options = {})
+    sym = symbolize(name)
+    raise "Child '#{sym}' already defined" if @children.has_key?(sym)
+    raise "Illegal name (#{sym})" if RESERVED_NAMES.include?(sym)
+    @children[sym] = element_class.new(self, sym, options)
+  end
+
+  def symbolize(name)
+    name.downcase.to_sym
+  end
+
+  def forget_children
+    children = {}
+  end
+
+  def remove_child(sym)
+    @children.delete(sym)
+  end
+
+  def destroy
+    `#{parent.element}.removeChild(#{element})`
+    parent.remove_child(@sym)
+  end
+
+  # Getter for children
+  def method_missing(method_name, *args, &block)
+    if @children.has_key?(method_name)
+      @children[method_name]
+    else
+      super
+    end
+  end
+end

data/opal/opal-ferro/ferro_factory.js.rb

@@ -0,0 +1,58 @@
+class FerroFactory
+
+  attr_reader :body
+
+  def initialize
+    @body = `document.body`
+    `while (document.body.firstChild) {document.body.removeChild(document.body.firstChild);}`
+  end
+
+  def create_element(target, type, parent, options = {})
+    # Create element
+    element = `document.createElement(#{type})`
+
+    # Add element to DOM
+    if options[:prepend]
+      `#{parent.element}.insertBefore(#{element}, #{options[:prepend].element})`
+    else
+      `#{parent.element}.appendChild(#{element})`
+    end
+
+    # Add ruby class to the node
+    `#{element}.classList.add(#{dasherize(target.class.name)})`
+
+    # Add ruby superclass to the node to allow for more generic styling
+    if target.class.superclass != FerroElement
+      `#{element}.classList.add(#{dasherize(target.class.superclass.name)})`
+    end
+
+    # Set ruby object_id as default element id
+    if !options.has_key?(:id)
+      `#{element}.id = #{target.object_id}`
+    end
+        
+    # Set attributes
+    options.each do |name, value|
+      case name
+      when :prepend
+        nil
+      when :content
+        `#{element}.appendChild(document.createTextNode(#{value}))`
+      else
+        `#{element}.setAttribute(#{name}, #{value})`
+      end
+    end
+
+    element
+  end
+
+  def dasherize(class_name)
+    return class_name if class_name !~ /[A-Z_]/
+    (class_name[0] + class_name[1..-1].gsub(/[A-Z]/){ |c| "-#{c}" }).downcase.gsub('_', '-')
+  end
+
+  def camelize(class_name)
+    return class_name if class_name !~ /-/
+    class_name.gsub(/(?:-|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.strip
+  end
+end

data/opal/opal-ferro/ferro_form_elements.js.rb

@@ -0,0 +1,160 @@
+class FerroForm < FerroElement
+  def _before_create
+    # Dont use a real <form> so we don't have to prevent default actions
+    @domtype  = :div
+  end
+end
+
+# :text, :password, :reset, :radio, :checkbox, :color,
+# :date, :datetime-local, :email, :month, :number,
+# :range, :search, :tel, :time, :url, :week
+class FerroFormInput < FerroElement
+  def _before_create
+    @domtype = :input
+    @options[:type] ||= :text
+    @options[:value] = option_replace :content
+    @disabled = option_replace :disabled, false
+  end
+
+  def value
+    `#{@element}.value`
+  end
+
+  def value=(value)
+    `#{@element}.value = #{value}`
+  end
+
+  def set_focus
+    # Doesn't work ?!
+    `#{element}.focus()`
+  end
+
+  def _after_create
+    disable if @disabled
+
+    if [:text, :password, :number].include?(@options[:type])
+      `#{@element}.addEventListener("keydown",function(e){self.$keydowned(e);})`
+    end
+  end
+
+  def keydowned(event)
+    entered if Native(event).keyCode == 13
+  end
+
+  def entered;end
+
+  def disable
+    set_attribute(:disabled, :disabled)
+  end
+
+  def enable
+    remove_attribute(:disabled)
+  end
+end
+
+class FerroFormLabel < FerroElement
+  def _before_create
+    @domtype = :label
+  end
+end
+
+class FerroFormFieldset < FerroElement
+  def _before_create
+    @domtype = :fieldset
+    @legend  = @options[:legend]
+  end
+end
+
+class FerroFormTextarea < FerroElement
+  def _before_create
+    @domtype = :textarea
+    @size    = { rows: 40, cols: 5 }
+  end
+end
+
+class FerroFormOutput < FerroElement
+  def _before_create
+    @domtype = :output
+  end
+end
+
+class FerroFormClickable < FerroFormInput
+  def _after_create
+    `#{@element}.addEventListener("click",function(e){#{clicked};document.activeElement.blur()})`
+    super
+  end
+
+  def clicked;end
+end
+
+class FerroFormButton < FerroFormClickable
+  def _before_create
+    @options[:type] = :button
+    super
+  end
+end
+
+class FerroFormSubmit < FerroFormClickable
+  def _before_create
+    @options[:type] = :submit
+    super
+  end
+end
+
+class FerroFormBlock < FerroFormClickable
+  def _before_create
+    super
+    @domtype = :div
+  end
+end
+
+# CheckBox with click callback
+class FerroFormCheckBox < FerroFormClickable
+  def _before_create
+    @options[:type] = :checkbox
+    super
+  end
+
+  def checked?
+    `#{@element}.checked`
+  end
+end
+
+# Select input
+class FerroFormSelect < FerroElement
+  def _before_create
+    @domtype = :select
+    @list = option_replace :list, {}
+    super
+  end
+
+  def after_create
+    @list.each do |value, content|
+      add_option(value, content)
+    end
+
+    `#{@element}.addEventListener("change",function(e){#{changed};document.activeElement.blur()})`
+    super
+  end
+
+  def changed;end
+
+  def add_option(value, content)
+    add_child "opt_#{value}", FerroElementVar, domtype: :option, value: value, content: content
+  end
+
+  def selection
+    option = `#{element}.options[#{element}.selectedIndex].value`
+    text   = `#{element}.options[#{element}.selectedIndex].text`
+    { option: option, text: text }
+  end
+
+  def select(option)
+    `for(var i=0; i < #{element}.options.length; i++) {
+      if (#{element}.options[i].value === #{option}) {
+        #{element}.selectedIndex = i;
+        break;
+      }
+    }`
+  end
+end

data/opal/opal-ferro/ferro_router.js.rb

@@ -0,0 +1,119 @@
+require 'native'
+
+class FerroRouter
+  
+  def initialize(page404)
+    @routes  = []
+    @page404 = page404
+    setup_navigation_listener
+  end
+
+  def add_route(path, callback)
+    @routes << { parts: path_to_parts(path), callback: callback }
+  end
+
+  def setup_navigation_listener
+    `window.onpopstate = function(e){#{navigated}}`
+  end
+
+  def replace_state(url)
+    `history.replaceState(null,null,#{url})`
+  end
+
+  def push_state(url)
+    `history.pushState(null,null,#{url})`
+  end
+
+  def go_to(url)
+    push_state(url)
+    navigated
+  end
+
+  def go_back
+    `history.back()`
+  end
+
+  def get_location
+    Native(`new URL(window.location.href)`)
+  end
+
+  def path_to_parts(path)
+    path.
+      downcase.
+      split('/').
+      map { |part| part.empty? ? nil : part.strip }.
+      compact
+  end
+
+  def decode(value)
+    `decodeURI(#{value})`
+  end
+
+  def navigated
+    url = get_location
+    @params = []
+
+    idx = match(path_to_parts(decode(url.pathname)), decode(url.search))
+
+    if idx
+      @routes[idx][:callback].call(@params)
+    else
+      @page404.call(url.pathname)
+    end
+  end
+
+  def match(path, search)
+    matches = get_matches(path)
+
+    if matches.length > 0
+      match = matches.sort { |m| m[1] }.first
+
+      @params = match[2]
+      add_search_to_params(search)
+
+      match[0]
+    else
+      nil
+    end
+  end
+
+  def get_matches(path)
+    matches = []
+
+    @routes.each_with_index do |route, i|
+      score, pars = score_route(route[:parts], path)
+      matches << [i, score, pars] if score > 0
+    end
+
+    matches
+  end
+
+  def score_route(parts, path)
+    score = 0
+    pars  = {}
+
+    if parts.length == path.length
+      parts.each_with_index do |part, i|
+        if part[0] == ':'
+          score += 1
+          pars["#{part[1..-1]}"] = path[i]
+        elsif part == path[i].downcase
+          score += 2
+        end
+      end
+    end
+
+    return score, pars
+  end
+
+  def add_search_to_params(search)
+    if !search.empty?
+      pars = search[1..-1].split('&')
+
+      pars.each do |par|
+        pair = par.split('=')
+        @params[ pair[0] ] = pair[1] if pair.length == 2
+      end
+    end
+  end
+end

data/opal/opal-ferro/ferro_sequence.js.rb

@@ -0,0 +1,12 @@
+class FerroSequence
+  
+  def initialize(label = nil)
+    @label   = label
+    @next_id = 0
+  end
+
+  def next
+    @next_id += 1
+    "#{@label}#{@next_id}"
+  end
+end

data/opal/opal-ferro/ferro_xhr.js.rb

@@ -0,0 +1,82 @@
+# Based on turbolinks/http_request
+require 'json'
+require 'native'
+
+class FerroXhr
+
+  NETWORK_FAILURE = 'Network error'
+  TIMEOUT_FAILURE = 'Timeout'
+
+  def initialize(url, callback, error_callback, options = {})
+    @url            = url
+    @callback       = callback
+    @error_callback = error_callback
+    @referrer       = options[:referrer] || 'Ferro'
+    @timeout        = options[:timeout]  || 5000
+    @accept         = options[:accept]   || 'application/json'
+    @xhr            = nil
+    @sent           = false
+
+    createXHR
+    send
+  end
+
+  def send
+    if @xhr && !@sent
+      @xhr.JS.send
+      @sent = true
+    end
+  end
+
+  def cancel
+    @xhr.JS.abort if @xhr && @sent
+  end
+
+  def createXHR
+    @xhr = `new XMLHttpRequest`
+    `#{@xhr}.open('GET', #{@url}, true)`
+    `#{@xhr}.timeout = #{@timeout}`
+  # `#{@xhr}.responseType = 'json'` if @accept == 'application/json'
+    `#{@xhr}.setRequestHeader('Accept', #{@accept})`
+    `#{@xhr}.setRequestHeader('Ferro-Referrer', #{@referrer})`
+    `#{@xhr}.addEventListener('load',    function(){#{requestLoaded}})`
+    `#{@xhr}.addEventListener('error',   function(){#{requestFailed}})`
+    `#{@xhr}.addEventListener('timeout', function(){#{requestTimedOut}})`
+    `#{@xhr}.addEventListener('abort',   function(){#{requestCanceled}})`
+    nil
+  end
+
+  def destroy
+    `#{@xhr} = null`
+  end
+
+  def requestLoaded
+    begin
+      status = Native(`#{@xhr}.status`)
+      raise if status >= 300
+      json = JSON.parse(`#{@xhr}.response`)
+      @callback.call(json)
+    rescue => error
+      @failed = true
+      @error_callback.call(status, error)
+    end
+
+    destroy
+  end
+
+  def requestFailed
+    @failed = true
+    @error_callback.call(`#{@xhr}.status`, Native(`#{@xhr}.response`))
+    destroy
+  end
+
+  def requestTimedOut
+    @failed = true
+    @error_callback.call(0, TIMEOUT_FAILURE)
+    destroy
+  end
+
+  def requestCanceled
+    destroy
+  end
+end

data/opal/opal-ferro.rb

@@ -0,0 +1,11 @@
+require 'opal'
+require 'opal-ferro/ferro_elementary'
+require 'opal-ferro/ferro_element'
+require 'opal-ferro/ferro_document'
+require 'opal-ferro/ferro_factory'
+require 'opal-ferro/ferro_router'
+require 'opal-ferro/ferro_xhr'
+require 'opal-ferro/ferro_sequence'
+require 'opal-ferro/ferro_base_elements'
+require 'opal-ferro/ferro_form_elements'
+require 'opal-ferro/ferro_components'

data/opal-ferro.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'opal-ferro/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'opal-ferro'
+  s.version       = Opal::Ferro::VERSION
+  s.author        = ['Ivo Herweijer']
+  s.email         = ['info@edwhs.nl']
+
+  s.summary       = %q{Simplifying web-development: no more html, just beautiful and simple Ruby code.}
+  s.description   = %q{Ferro is a small Ruby library on top of Opal that enables an object-oriented programming style for creating code that runs in the webbrowser. No more distractions like HTML and searching for DOM elements, just beautiful and simple Ruby code. Front-End-Ruby-ROcks!}
+  s.homepage      = 'https://github.com/easydatawarehousing/opal-ferro'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'opal', '~> 0.10'
+
+  s.add_development_dependency 'bundler',  '~> 1.16'
+  s.add_development_dependency 'rake',     '~> 10.0'
+  # s.add_development_dependency 'yard',     '~> 0.8.7'
+  s.add_development_dependency 'minitest', '~> 5.0'
+  # s.add_development_dependency 'selenium-webdriver', '~> 3.8'
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: opal-ferro
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Ivo Herweijer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Ferro is a small Ruby library on top of Opal that enables an object-oriented
+  programming style for creating code that runs in the webbrowser. No more distractions
+  like HTML and searching for DOM elements, just beautiful and simple Ruby code. Front-End-Ruby-ROcks!
+email:
+- info@edwhs.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/opal-ferro.rb
+- lib/opal-ferro/version.rb
+- lib/opal/ferro.rb
+- opal-ferro.gemspec
+- opal/opal-ferro.rb
+- opal/opal-ferro/ferro_base_elements.js.rb
+- opal/opal-ferro/ferro_components.js.rb
+- opal/opal-ferro/ferro_document.js.rb
+- opal/opal-ferro/ferro_element.js.rb
+- opal/opal-ferro/ferro_elementary.js.rb
+- opal/opal-ferro/ferro_factory.js.rb
+- opal/opal-ferro/ferro_form_elements.js.rb
+- opal/opal-ferro/ferro_router.js.rb
+- opal/opal-ferro/ferro_sequence.js.rb
+- opal/opal-ferro/ferro_xhr.js.rb
+homepage: https://github.com/easydatawarehousing/opal-ferro
+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.6.14
+signing_key: 
+specification_version: 4
+summary: 'Simplifying web-development: no more html, just beautiful and simple Ruby
+  code.'
+test_files: []