asbru 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: adbc029751ba4d56cc4fa21e754fdc1dbd4e7adf82fb69325623fbeb06243fb2
+  data.tar.gz: 19f3ed4cafb6cdde19827b9cdaa0ff5df9608fef2c9688c0f2ce17ccbcfe2e36
+SHA512:
+  metadata.gz: 36d7cfc112787a88ee64c864275163c3721a13e6bbae0b2cc454088e342e34c137568fc1ebb964e107bec310ab3ee9deae08ae6c310e35f6c1e54c01d9f99a2e
+  data.tar.gz: b17440674f8b014ad3c081c77427240a76a989b84c37475724935cc42664ed37ef49b2edad21f1a6a5efae5cad29a760575362e07836889b651dfb84e805bd61

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Stev-0
+
+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,204 @@
+# Asbru
+Asbru is meant as a bridge between Rails and React that (hopefully) allows us
+to enjoy the perks of both ecosystems without having to write huge amounts of
+boilerplate.
+Meanwhile there is some added safety in the form of raises on loading
+non-existing components, and syntactic sugar(less curlies and parens) in view
+code AND there are some solutions for patterns of code use we notice.
+
+## Installation
+
+```ruby
+gem 'asbru'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install asbru
+```
+
+## Usage
+Require 'asbru/ragna' and the C and CML modules are available everywhere.
+Your application helper is a great place for the require as most code
+that works in tandem with Asbru should go there.
+
+in app/helpers/application_helper.rb
+```ruby
+require 'asbru/ragna'
+
+module ApplicationHelper
+  include Asbru::RailsHelpers
+  ...
+end
+
+```
+
+Now you can use components in your rails views in `Savage` mode:
+
+```erb
+<%= C.layout_banner(
+    steps: [],
+    title: { color: 'light', text: t('dossier.overview.title') },
+    color: 'energized-500') %>
+<%= C.ui_divider(
+    height: 60,
+    color: 'transparent',
+    hideMobileS: true) %>
+
+<%= CML.vertical_spacer 10 %>
+```
+
+or in `Sage` mode:
+
+```erb
+<%= C::Layout.banner(color: 'energized-500',
+    title: { color: 'light', text: t('dossier.overview.title') }) %>
+<%= C::Ui.divider(
+    height: 60,
+    color: 'transparent',
+    hideMobileS: true) %>
+
+```
+
+And you can write CML
+```erb
+<%= CML.h1 'Hello world!' %>
+<%= CML.vertical_spacer 10 %>
+<%= CML.p 'In the land where I was born.' %>
+<%= CML.p 'Lives a man beneath the sea.' %>
+<%= CML.p '...', color: 'stable-500' %>
+```
+
+
+## Lets take a deeper dive
+
+When we open the rails console we can see that asbru has some benefits over
+loading components just via react rails:
+
+```irb
+2.7.1 :001 > require 'asbru/components/sage'
+2.7.1 :002 > C = Asbru::Components::Sage
+2.7.1 :003 > C.constants
+ => []
+2.7.1 :004 > C.setup
+2.7.1 :005 > C.constants
+ => [:Layout, :Modal, :Progress, :Form, :Styles, :Ui, :Badge, :Button, :Table, :Text, :Card]
+2.7.1 :006 >C::Ui.methods - Module.methods
+ => [:image, :logo, :action_sheet, :icon, :divider, :icon_phone, :snackbar, :tooltip, :helper_implementation_class, :helper_implementation_class=, :react_component]
+2.7.1 :007 > C::Ui.divider margin: 20
+ => "<div data-react-class=\"ui.Divider\" data-react-props=\"{&quot;margin&quot;:20}\" data-react-cache-id=\"ui.Divider-0\"></div>"
+2.7.1 :008 > C::iU.divider margin: 20
+Traceback (most recent call last):
+        2: from (irb):26
+        1: from (irb):27:in `rescue in irb_binding'
+NameError (uninitialized constant Asbru::Components::Sage::Iu)
+2.7.1 :009 > C::Ui.blarg margin: 20
+Traceback (most recent call last):
+        1: from (irb):26
+NoMethodError (undefined method `blarg' for Asbru::Components::Sage::Ui:Class)
+```
+
+We have a list of available folders and componentent available in Ruby and we
+raise errors when we use the wrong wrong module or method names.
+
+To use `Sage` a json file names /app/javascript/components/components.json is
+required. This file can be generated with the following script. We have no
+cannonical way of solving this yet and it requires certain best practices to be
+followed during component development.
+
+```js
+#!/usr/bin/env node
+
+const dirTree = require('directory-tree');
+const fs = require('fs');
+const tree = dirTree('./app/javascript/components', { extensions: /\.js$/ });
+
+const components =
+  tree.children.length > 0
+    ? tree.children
+        .map((child) => {
+          return {
+            folder: child.name,
+            components:
+              child.children.length > 0
+                ? child.children
+                    .filter((c) => c.type == 'directory')
+                    .map((c) =>
+                      c.name
+                        .split('-')
+                        .map((c) => c.charAt(0).toUpperCase() + c.slice(1))
+                        .join('')
+                    )
+                : {},
+          };
+        })
+        .filter((f) => f.components.length > 0)
+    : {};
+fs.writeFile(
+  './app/javascript/components/components.json',
+  JSON.stringify(components),
+  'utf8',
+  () => {
+    console.log('Component names have been collected.');
+  }
+);
+```
+
+
+## Modules:
+- Component::Savage
+  Components rendered via method_missing with no extra safety.
+
+- Component::Sage
+  Components loaded with additional safety. Requires a bit of additional wiring.
+
+- CML
+  Compose HTML pages with web components. Makes writing a page with Components
+  more similar to writing html.
+
+- LinkHelper
+  a Rails link_to with webcomponents
+
+- FormBuilder
+  a Rails form builder using webcomponents
+
+- IMG
+  A rails image_tag clone
+
+## Groups
+- Ragna
+  Load all Asbru in a omakasa way(with sage components).
+
+- RailsHelpers
+  Load all Asbru Rails helpers
+
+## Opinions of the author
+1. Writing Plain old HTML is fun simple and quite universal. Lets make writing
+components intuitive.
+2. Less noise makes code more readable.
+3. Less configuration makes working on projects smoother.
+
+
+## Design goals
+If there is such a thing as "The Ivaldi Way" we will stick as close to it as we
+can.
+
+## TODO:
+
+- Make the helpers available using both `Sage` and `Savage`.
+- Raise an error when incorrect attributes have been supplied to a component.
+- Add image tag support.
+- Tie in with rails load cycle.
+- Run the js script from the gem(on rails startup in production and on ).
+- Remove the react-rails dependency(or get a better idea about its function).
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,27 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Asbru'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/asbru.rb

@@ -0,0 +1,5 @@
+require "asbru/railtie"
+
+module Asbru
+
+end

data/lib/asbru/cml.rb

@@ -0,0 +1,67 @@
+require 'asbru/components/savage'
+
+module Asbru
+  # This module defines a bunch of methods that
+  module CML
+    C = Asbru::Components::Savage
+
+    # Problems:
+    # How can we make this module work with Sage/Savage depending on config?
+    # Do we want to do that?
+
+    # Ideas:
+    # 1. We can make Sage implement to exactly the same interface as Savage and
+    #  somehow inject it.
+    # 2. We could also ALWAYS load the sage classed needed here and call these
+    # required.
+    #
+    # I think I prefer 1 even though the syntax of Sage is nicer imo.
+    class << self
+      def p text, **opts
+        C.text_content text: text, **opts
+      end
+
+      def h1 text, **opts
+        C.text_title size: 'h1', text: text
+      end
+
+      def h2 text, **opts
+        C.text_title size: 'h2', text: text
+      end
+
+      def h3 text, **opts
+        C.text_title size: 'h3', text: text
+      end
+
+      def h4 text, **opts
+        C.text_title size: 'h4', text: text
+      end
+
+      def h5 text, **opts
+        C.text_title size: 'h5', text: text
+      end
+
+      def hr color: 'stable-500'
+        C.ui_divider color: color, height: 1
+      end
+
+      def vertical_spacer height
+        C.ui_divider color: :transparent, height: height
+      end
+
+      def table_row(*cells)
+        { data: cells }
+      end
+
+      def table_cell(text, action: nil, method: nil, confirm: nil, color: nil)
+        cell = { text: text}
+        cell[:color] = color if color.present?
+        cell[:action] = action if action.present?
+        cell[:customData] = {}
+        cell[:customData]['data-method'] = method if method.present?
+        cell[:customData]['data-confirm'] = confirm if confirm.present?
+        cell
+      end
+    end
+  end
+end

data/lib/asbru/components.rb

@@ -0,0 +1,4 @@
+module Asbru
+  module Components
+  end
+end

data/lib/asbru/components/sage.rb

@@ -0,0 +1,48 @@
+module Asbru
+  module Components
+    # This module uses components.json to see what components are available to
+    # be rendered. Because it defines methods on runtime instead of relying on
+    # method_missing its quite a bit faster and provides better feedback in
+    # case of errors. This implementation is just a PoC and doesn't work atm.
+    # More on this later!
+    class Sage
+      extend ::React::Rails::ViewHelper
+      class << self
+        def setup
+          file = File.open(Rails.root.join('app',
+              'javascript',
+              'components',
+              'components.json'))
+
+          JSON.parse(file.read).each do |folder|
+            cname = folder['folder'].capitalize
+            const_set cname, Class.new
+            klass = "Asbru::Components::Sage::#{cname}".constantize
+            klass.extend ::React::Rails::ViewHelper
+
+            folder['components'].each do |component_name|
+              method_name = component_name.underscore.to_sym
+
+              klass.define_singleton_method(method_name) do |**opts|
+                react_component "#{folder['folder']}.#{component_name}", **opts
+              end
+            end
+          end
+        end
+
+        # We use method missing to enable the make this available via the same
+        # API as Savage. The other API here is nicer and maybe we should create
+        # a way to disable the savage API.
+        def method_missing(method_id, **opts)
+          return super if self.respond_to? :method_id
+
+          name_parts = method_id.to_s.split('_')
+          namespace = name_parts.shift.capitalize
+
+          "Asbru::Components::Sage::#{namespace}".constantize
+              .send(name_parts.join('_'), **opts)
+        end
+      end
+    end
+  end
+end

data/lib/asbru/components/savage.rb

@@ -0,0 +1,23 @@
+module Asbru
+  module Components
+    # This module is used to generate react components in the views and loads
+    # them via method missing without additional checking.
+    # It doesn't offer any benefits over react::rails
+    class Savage
+      extend ::React::Rails::ViewHelper
+      class << self
+        def method_missing(method_id, **opts)
+          if self.respond_to? :method_id
+            super
+          end
+
+          name_parts = method_id.to_s.split('_')
+          namespace = name_parts.shift
+          name = name_parts.map(&:capitalize).join('')
+
+          react_component "#{namespace}.#{name}", opts
+        end
+      end
+    end
+  end
+end

data/lib/asbru/form_builder.rb

@@ -0,0 +1,214 @@
+require 'asbru/components/savage'
+
+module Asbru
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    module Helper
+      def asbru_form(**options, &block)
+        options.reverse_merge!(builder: Asbru::FormBuilder)
+        form_with(**options, &block)
+      end
+
+      def asbru_form_for(record, **options, &block)
+        options.reverse_merge!(builder: Asbru::FormBuilder)
+        form_for(record, **options, &block)
+      end
+
+      def asbru_form_with(**options, &block)
+        asbru_form(**options, &block)
+      end
+
+      def ivaldi_form_for(record, **options, &block)
+        asbru_form_for(record, **options, &block)
+      end
+
+      def ivaldi_form_with(**options, &block)
+        asbru_form(**options, &block)
+      end
+    end
+
+    BASIC_FORM_FIELDS = [
+      { submit: { text: 'Submit', type: 'submit' } },
+      { date_field: { type: 'datepicker' } },
+      { password_field: { type: 'password' } },
+      { text_area: { type: 'textarea' } },
+      { email_field: { type: 'email' } },
+      { check_box: { type: 'checkbox' } },
+      { file_field: { type: 'file' } },
+      { text_field: {} },
+      { telephone_field: { type: 'tel '}}
+    ].freeze
+
+    def errors(name)
+      if object.respond_to?(:errors) &&
+          !(name.nil? || object.errors[name].empty?)
+        object.errors.messages.dig(name)
+      end
+    end
+
+    def tag_name_for(method, multiple = false)
+      name = ActionView::Helpers::Tags::TextField.new(object_name,
+          method, {})
+        .send(:tag_name)
+      name += '[]' if multiple
+      name
+    end
+
+    def render_form_element(attribute, options)
+      new_options = options.merge(
+        {
+          name: tag_name_for(attribute),
+          errors: errors(attribute)
+        }
+      )
+
+      if @object.present? && attribute.present?
+        if options[:value].nil?
+          # if type of column is date, use default date format
+          if @object.class.try(:columns_hash).present? &&
+              @object.class
+                .columns_hash[attribute.to_s]
+                .try(:type) == :date && @object.send(attribute).present?
+            new_options[:value] = I18n.l(@object.send(attribute),
+                format: I18n.t('date_format.default'))
+          else
+            new_options[:value] = @object.send(attribute)
+          end
+        end
+        if options[:label].nil?
+          new_options[:label] = I18n.t(attribute,
+              scope: "activerecord.attributes.#{@object.class.name.downcase}")
+        end
+      end
+
+
+      Asbru::Components::Savage.form_element **new_options
+    end
+
+    def create_options(attribute, choices, chosen)
+      choices.to_h.map do |key, value|
+        {
+          label: key,
+          value: value,
+          name: tag_name_for(attribute),
+          checked: @object.nil? ? false :
+              @object.send(attribute) == chosen
+        }
+      end
+    end
+
+    def create_collection_options(attribute,
+        collection,
+        value_method,
+        text_method,
+        _options,
+        multiple = false)
+      collection.map do |item|
+        {
+          label: item.send(text_method),
+          value: item.send(value_method),
+          name: tag_name_for(attribute, multiple),
+          checked: if @object.nil?
+             false
+           else
+             if @object.send(attribute).is_a?(Array)
+               @object.send(attribute).include?(item.send(value_method))
+             else
+               @object.send(attribute).to_s == item.send(value_method).to_s
+             end
+           end
+
+        }
+      end
+    end
+
+    BASIC_FORM_FIELDS.each do |item|
+      define_method item.keys.first do |attribute = nil, options = {}|
+        render_form_element(attribute, options.reverse_merge(item.values.first))
+      end
+    end
+
+    def collection_radio_buttons(attribute,
+        collection,
+        value_method,
+        text_method,
+        options = {},
+        html_options = {})
+      render_form_element(attribute, options.merge(html_options).merge(
+        {
+          type: 'radio',
+          options: create_collection_options(attribute,
+              collection,
+              value_method,
+              text_method,
+              options, false)
+        }
+      ))
+    end
+
+    def collection_check_boxes(attribute,
+        collection,
+        value_method,
+        text_method,
+        options = {},
+        html_options = {})
+      render_form_element(attribute, options.merge(html_options).merge(
+        {
+          type: 'checkbox',
+          options: create_collection_options(attribute,
+              collection,
+              value_method,
+              text_method,
+              options,
+              true)
+        }
+      ))
+    end
+
+    def select(attribute,
+        choices = nil,
+        chosen = nil,
+        options = {},
+        html_options = {})
+      render_form_element(
+          attribute, options.merge(html_options).merge(
+          {
+            type: 'select',
+            options: create_options(attribute, choices, chosen)
+          }
+        )
+        )
+    end
+
+    def collection_select(attribute,
+        collection,
+        value_method,
+        text_method,
+        options = {},
+        html_options = {})
+      if options[:without_react].present?
+        super
+      else
+        render_form_element(attribute, options.merge(html_options).merge(
+          {
+            type: 'select',
+            options: create_collection_options(attribute,
+              collection,
+              value_method,
+              text_method,
+              options)
+          }
+        ))
+      end
+    end
+
+    def check_box(attribute, options = {})
+      render_form_element(
+          attribute, { type: 'hidden', value: 'false', label: false }
+        ).concat(
+        render_form_element(
+            attribute, options.merge({ type: 'checkbox' })
+          )
+      )
+    end
+  end
+end

data/lib/asbru/links.rb

@@ -0,0 +1,29 @@
+require 'asbru/components/savage'
+
+module Asbru
+  module Links
+    module Helper
+      def asbru_link(text,
+          url,
+          method: nil,
+          link: true,
+          confirm: nil,
+          **options)
+
+        options[:text] = text
+        options[:action] = url
+        options[:link] = link
+
+        options[:customData] = {}
+        options[:customData][:'data-method'] = method if method.present?
+        options[:customData][:'data-confirm'] = confirm if confirm.present?
+        options[:customData].merge(options[:custom_data]) if options[:custom_data]
+        Asbru::Components::Savage.button_button(**options)
+      end
+
+      def asbru_link_to(text, url, **options)
+        asbru_link text, url, **options
+      end
+    end
+  end
+end

data/lib/asbru/ragna.rb

@@ -0,0 +1,15 @@
+# We need some side effects to happen!
+require 'asbru/rails_helpers'
+require 'asbru/components/sage'
+require 'asbru/cml'
+
+# We use the C for binding components. We might want to make this configurable
+# later on
+::C = Asbru::Components::Sage.tap(&:setup)
+::CML = Asbru::CML
+
+module Asbru
+  module Ragna
+    include Asbru::RailsHelpers
+  end
+end

data/lib/asbru/rails_helpers.rb

@@ -0,0 +1,9 @@
+require 'asbru/form_builder'
+require 'asbru/links'
+
+module Asbru
+  module RailsHelpers
+    include Asbru::FormBuilder::Helper
+    include Asbru::Links::Helper
+  end
+end

data/lib/asbru/railtie.rb

@@ -0,0 +1,4 @@
+module Asbru
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/asbru/version.rb

@@ -0,0 +1,3 @@
+module Asbru
+  VERSION = '0.0.1'
+end

data/lib/asbru/view_helpers.rb

@@ -0,0 +1,6 @@
+module Asbru
+  class ViewHelpers
+    include Asbru::FormBuilder::Helper
+    include Asbru::LinkHelper
+  end
+end

data/lib/tasks/asbru_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :asbru do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: asbru
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Stev-0
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.5
+- !ruby/object:Gem::Dependency
+  name: react-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Creating component based webpages with short hand syntax.
+email:
+- skemp@adflow.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/asbru.rb
+- lib/asbru/cml.rb
+- lib/asbru/components.rb
+- lib/asbru/components/sage.rb
+- lib/asbru/components/savage.rb
+- lib/asbru/form_builder.rb
+- lib/asbru/links.rb
+- lib/asbru/ragna.rb
+- lib/asbru/rails_helpers.rb
+- lib/asbru/railtie.rb
+- lib/asbru/version.rb
+- lib/asbru/view_helpers.rb
+- lib/tasks/asbru_tasks.rake
+homepage: https://rubygems.org/gems/asbru
+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: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Asbru is a tool for creating component based webpages.
+test_files: []