amber_component 0.0.2

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+::Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.libs << 'test/fixtures'
+  # ignore tests of rails apps
+  t.test_files = ::FileList['test/**/*_test.rb'] - ::FileList['test/apps/**/*_test.rb']
+end
+
+require 'rubocop/rake_task'
+
+::RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/amber_component.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "lib/amber_component/version"
+
+::Gem::Specification.new do |spec|
+  spec.name = "amber_component"
+  spec.version = ::AmberComponent::VERSION
+  spec.authors = ['Ruby-Amber', 'Mateusz Drewniak', 'Garbus Beach']
+  spec.email = ['matmg24@gmail.com', 'piotr.garbus.garbicz@gmail.com']
+
+  spec.summary = "A simple component library which seamlessly hooks into your Rails project."
+  spec.description = <<~DESC
+    A simple component library which seamlessly hooks into your Rails project
+    and allows you to create simple backend components.
+
+    They work like mini controllers which are bound with their view.
+  DESC
+  spec.homepage = 'https://github.com/amber-ruby/amber_component'
+  spec.license = 'MIT'
+  spec.required_ruby_version = ">= 2.6.0"
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata['rubygems_mfa_required'] = 'true'
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = ::Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| ::File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "memery", ">= 1.4.1"
+  spec.add_dependency "rails", ">= 6"
+  spec.add_dependency "tilt", ">= 2.0.10"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/amber_component/base.rb

@@ -0,0 +1,492 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'erb'
+require 'tilt'
+require 'active_model/callbacks'
+require 'memery'
+
+require_relative './style_injector'
+
+# Abstract class which serves as a base
+# for all Amber Components.
+#
+# There are a few life cycle callbacks that can be defined.
+# The same way as in `ActiveRecord` models and `ActionController` controllers.
+#
+# - before_render
+# - around_render
+# - after_render
+# - before_initialize
+# - around_initialize
+# - after_initialize
+#
+#    class ButtonComponent < ::AmberComponent::Base
+#      # You can provide a Symbol of the method that should be called
+#      before_render :before_render_method
+#      # Or provide a block that will be executed
+#      after_initialize do
+#        # Your code here
+#      end
+#
+#      def before_render_method
+#        # Your code here
+#      end
+#    end
+#
+#
+# @abstract Create a subclass to define a new component.
+module ::AmberComponent
+  class Base # :nodoc:
+    extend ::ActiveModel::Callbacks
+
+    include Helper
+
+    # @return [Regexp]
+    VIEW_FILE_REGEXP  = /^view\./.freeze
+    # @return [Regexp]
+    STYLE_FILE_REGEXP = /^style\./.freeze
+
+    # View types with built-in embedded Ruby
+    #
+    # @return [Set<Symbol>]
+    VIEW_TYPES_WITH_RUBY = ::Set[:erb, :haml, :slim].freeze
+    # @return [Set<Symbol>]
+    ALLOWED_VIEW_TYPES = ::Set[:erb, :haml, :slim, :html, :md, :markdown].freeze
+    # @return [Set<Symbol>]
+    ALLOWED_STYLE_TYPES = ::Set[:sass, :scss, :less].freeze
+
+    class << self
+      include ::Memery
+
+      # @param kwargs [Hash{Symbol => Object}]
+      # @return [String]
+      def run(**kwargs, &block)
+        comp = new(**kwargs)
+
+        comp.render(&block)
+      end
+
+      alias call run
+
+
+      # @return [String]
+      memoize def asset_dir_path
+        class_const_name = name.split('::').last
+        component_file_path, = module_parent.const_source_location(class_const_name)
+
+        component_file_path.delete_suffix('.rb')
+      end
+
+      # @return [String]
+      def view_path
+        asset_path view_file_name
+      end
+
+      # @return [String, nil]
+      def view_file_name
+        files = asset_file_names(VIEW_FILE_REGEXP)
+        raise MultipleViews, "More than one view file for `#{name}` found!" if files.length > 1
+
+        files.first
+      end
+
+      # @return [Symbol]
+      def view_type
+        (view_file_name.split('.')[1..].reject { _1.match?(/erb/) }.last || 'erb')&.to_sym
+      end
+
+      # @return [String]
+      def style_path
+        asset_path style_file_name
+      end
+
+      # @return [String, nil]
+      def style_file_name
+        files = asset_file_names(STYLE_FILE_REGEXP)
+        raise MultipleStyles, "More than one style file for `#{name}` found!" if files.length > 1
+
+        files.first
+      end
+
+      # @return [Symbol]
+      def style_type
+        (style_file_name.split('.')[1..].reject { _1.match?(/erb/) }.last || 'erb')&.to_sym
+      end
+
+      # Memoize these methods in production
+      if defined?(::Rails) && ::Rails.env.production?
+        memoize :view_path
+        memoize :view_file_name
+        memoize :view_type
+
+        memoize :style_path
+        memoize :style_file_name
+        memoize :style_type
+      end
+
+      # Register an inline view by returning a String from the passed block.
+      #
+      # Usage:
+      #
+      #   view do
+      #     <<~ERB
+      #       <h1>
+      #         Hello <%= @name %>
+      #       </h1>
+      #     ERB
+      #   end
+      #
+      # or:
+      #
+      #   view :haml do
+      #     <<~HAML
+      #       %h1
+      #         Hello
+      #         = @name
+      #     HAML
+      #   end
+      #
+      # @param type [Symbol]
+      # @return [void]
+      def view(type = :erb, &block)
+        @method_view = TypedContent.new(type: type, content: block)
+      end
+
+      # ERB/Haml/Slim view registered through the `view` method.
+      #
+      # @return [TypedContent]
+      attr_reader :method_view
+
+      # Register an inline style by returning a String from the passed block.
+      #
+      # Usage:
+      #
+      #   style do
+      #     '.my-class { color: red; }'
+      #   end
+      #
+      # or:
+      #
+      #    style :sass do
+      #     <<~SASS
+      #       .my-class
+      #         color: red
+      #     SASS
+      #    end
+      #
+      # @param type [Symbol]
+      # @return [void]
+      def style(type = :css, &block)
+        @method_style = TypedContent.new(type: type, content: block)
+      end
+
+      # CSS/SCSS/Sass styles registered through the `style` method.
+      #
+      # @return [TypedContent]
+      attr_reader :method_style
+
+      private
+
+      # @param subclass [Class]
+      # @return [void]
+      def inherited(subclass)
+        # @type [Module]
+        parent_module = subclass.module_parent
+        method_body = proc do |**kwargs, &block|
+          subclass.run(**kwargs, &block)
+        end
+
+        Helper.define_method(subclass.name, &method_body) && return if parent_module.equal? ::Object
+
+        parent_module.define_singleton_method(subclass.name.split('::').last, &method_body)
+      end
+
+      # @param file_name [String, nil]
+      # @return [String, nil]
+      def asset_path(file_name)
+        return unless file_name
+
+        ::File.join(asset_dir_path, file_name)
+      end
+
+      # Returns the name of the file inside the asset directory
+      # of this component that matches the provided `Regexp`
+      #
+      # @param type_regexp [Regexp]
+      # @return [Array<String>]
+      def asset_file_names(type_regexp)
+        return [] unless ::File.directory?(asset_dir_path)
+
+        ::Dir.entries(asset_dir_path).select do |file|
+          next unless ::File.file?(::File.join(asset_dir_path, file))
+
+          file.match? type_regexp
+        end
+      end
+    end
+
+    define_model_callbacks :initialize, :render
+
+    # @param kwargs [Hash{Symbol => Object}]
+    def initialize(**kwargs)
+      run_callbacks :initialize do
+        bind_variables(kwargs)
+      end
+    end
+
+    # @return [String]
+    def render(&block)
+      run_callbacks :render do
+        element  = inject_views(&block)
+        styles   = inject_styles
+        element += styles unless styles.nil?
+        element.html_safe
+      end
+    end
+
+    def render_in(context)
+      byebug
+    end
+
+    private
+
+    # @param kwargs [Hash{Symbol => Object}]
+    # @return [void]
+    def bind_variables(kwargs)
+      kwargs.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    # Helper method to render view from string or with other provided type.
+    #
+    # Usage:
+    #
+    #   render_custom_view('<h1>Hello World</h1>')
+    #
+    # or:
+    #
+    #   render_custom_view content: '**Hello World**', type: 'md'
+    #
+    # @param style [TypedContent, Hash{Symbol => String, Symbol, Proc}, String]
+    # @return [String, nil]
+    def render_custom_view(view, &block)
+      return '' unless view
+      return view if view.is_a?(::String)
+
+      view = TypedContent.wrap(view)
+      type = view.type
+      content = view.to_s
+
+      if content.empty?
+        raise EmptyView, <<~ERR.squish
+          Custom view for `#{self.class}` from view method cannot be empty!
+        ERR
+      end
+
+      unless ALLOWED_VIEW_TYPES.include? type
+        raise UnknownViewType, <<~ERR.squish
+          Unknown view type for `#{self.class}` from view method!
+          Check return value of param type in `view :[type] do`
+        ERR
+      end
+
+      unless VIEW_TYPES_WITH_RUBY.include? type
+        # first render the content with ERB if the
+        # type does not support embedding Ruby by default
+        content = render_string(content, :erb, block)
+      end
+
+      render_string(content, type, block)
+    end
+
+    # @return [String]
+    def render_view_from_file(&block)
+      view_path = self.class.view_path
+      return '' if view_path.nil? || !::File.file?(view_path)
+
+      content = ::File.read(view_path)
+      type = self.class.view_type
+
+      unless VIEW_TYPES_WITH_RUBY.include? type
+        content = render_string(content, :erb, block)
+      end
+
+      render_string(content, type, block)
+    end
+
+    # Method returning view from method in class file.
+    # Usage:
+    #
+    #   view do
+    #     <<~HTML
+    #       <h1>
+    #         Hello <%= @name %>
+    #       </h1>
+    #     HTML
+    #   end
+    #
+    # or:
+    #
+    #   view :haml do
+    #     <<~HAML
+    #       %h1
+    #         Hello
+    #         = @name
+    #     HAML
+    #   end
+    #
+    # @return [String]
+    def render_class_method_view(&block)
+      render_custom_view(self.class.method_view, &block)
+    end
+
+    # Method returning view from params in view.
+    # Usage:
+    #
+    #   <%= ExampleComponent data: data, view: "<h1>Hello #{@name}</h1>" %>
+    #
+    # or:
+    #
+    #   <%= ExampleComponent data: data, view: { content: "<h1>Hello #{@name}</h1>", type: 'erb' } %>
+    #
+    # @return [String]
+    def render_view_from_inline(&block)
+      data = \
+        if @view.is_a? String
+          TypedContent.new(
+            type: :erb,
+            content: @view
+          )
+        else
+          @view
+        end
+
+      render_custom_view(data, &block)
+    end
+
+    # @return [String]
+    def inject_views(&block)
+      view_from_file   = render_view_from_file(&block)
+      view_from_method = render_class_method_view(&block)
+      view_from_inline = render_view_from_inline(&block)
+
+      view_content = view_from_file unless view_from_file.empty?
+      view_content = view_from_method unless view_from_method.empty?
+      view_content = view_from_inline unless view_from_inline.empty?
+
+      if view_content.nil? || view_content.empty?
+        raise ViewFileNotFound, "View for `#{self.class}` could not be found!"
+      end
+
+      view_content
+    end
+
+    # Helper method to render style from css string or with other provided type.
+    #
+    # Usage:
+    #
+    #   render_custom_style('.my-class { color: red; }')
+    #
+    # or:
+    #
+    #   render_custom_style style: '.my-class { color: red; }', type: 'sass'
+    #
+    # @param style [TypedContent, Hash{Symbol => Symbol, String, Proc}, String]
+    # @return [String, nil]
+    def render_custom_style(style)
+      return '' unless style
+      return style if style.is_a?(::String)
+
+      style = TypedContent.wrap(style)
+      type = style.type
+      content = style.to_s
+
+      if content.empty?
+        raise EmptyStyle, <<~ERR.squish
+          Custom style for `#{self.class}` from style method cannot be empty!
+        ERR
+      end
+
+      unless ALLOWED_STYLE_TYPES.include? type
+        raise UnknownStyleType, <<~ERR.squish
+          Unknown style type for `#{self.class}` from style method!
+          Check return value of param type in `style :[type] do`
+        ERR
+      end
+
+      # first render the content with ERB
+      content = render_string(content, :erb)
+
+      render_string(content, type)
+    end
+
+    # Method returning style from file (style.(css|sass|scss|less)) if exists.
+    #
+    # @return [String]
+    def render_style_from_file
+      style_path = self.class.style_path
+      return '' unless style_path
+
+      content = ::File.read(style_path)
+      type = self.class.style_type
+
+      return content if type == :css
+
+      content = render_string(content, :erb)
+      render_string(content, type)
+    end
+
+    # Method returning style from method in class file.
+    # Usage:
+    #
+    #   style do
+    #     '.my-class { color: red; }'
+    #   end
+    #
+    # or:
+    #
+    #    style :sass do
+    #     <<~SASS
+    #       .my-class
+    #         color: red
+    #     SASS
+    #    end
+    #
+    # @return [String]
+    def render_class_method_style
+      render_custom_style(self.class.method_style)
+    end
+
+    # Method returning style from params in view.
+    # Usage:
+    #
+    #   <%= ExampleComponent data: data, style: '.my-class { color: red; }' %>
+    #
+    # or:
+    #
+    #   <%= ExampleComponent data: data, style: {style: '.my-class { color: red; }', type: 'sass'} %>
+    #
+    # @return [String]
+    def render_style_from_inline
+      render_custom_style(@style)
+    end
+
+    # @param content [String]
+    # @param type [Symbol]
+    # @param block [Proc, nil]
+    # @return [String]
+    def render_string(content, type, block = nil)
+      ::Tilt[type].new { content }.render(self, &block)
+    end
+
+    # @return [String]
+    def inject_styles
+      style_content = render_style_from_file + render_class_method_style + render_style_from_inline
+      return if style_content.empty?
+
+      ::AmberComponent::StyleInjector.inject(style_content)
+    end
+  end
+end

data/lib/amber_component/helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ::AmberComponent
+  # Contains methods for quickly rendering
+  # components defined under the root namespace `Object`.
+  module Helper
+  end
+end

data/lib/amber_component/style_injector.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+# Helper class for injecting styles into DOM.
+class ::AmberComponent::StyleInjector
+  class << self
+
+    # Injects styles into the DOM, or returns string if
+    # DOM stucture is not available.
+    #
+    # @param style [String]
+    # @return [String, nil]
+    def inject(style)
+      injector = new(style)
+      injector.run
+    end
+  end
+
+  # @param style [String]
+  def initialize(style)
+    @style = style
+  end
+
+  # @return [void]
+  def run
+    return dom_tag unless dom_available?
+
+    insert_style_in_head
+    nil
+  end
+
+  private
+
+  # @return [Boolean]
+  def dom_available?
+    false
+    # check for header in DOM rendrer
+  end
+
+  # @return [void]
+  def insert_style_in_head
+    false
+  end
+
+  # @return [String]
+  def dom_tag
+    <<~HTML
+      <style type='text/css'>#{@style}</style>
+    HTML
+  end
+end

data/lib/amber_component/typed_content.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ::AmberComponent
+  # Contains the content and type of an asset.
+  class TypedContent
+    class << self
+      # @param val [Hash, self]
+      # @return [self]
+      def wrap(val)
+        return val if val.is_a?(self)
+
+        unless val.respond_to?(:[])
+          raise InvalidType, "`TypedContent` should be a `Hash` or `#{self}` but was `#{val.class}` (#{val.inspect})"
+        end
+
+        new(type: val[:type], content: val[:content])
+      end
+
+      alias [] wrap
+    end
+
+    # @param type [Symbol, String, nil]
+    # @param content [String, Proc, nil]
+    def initialize(type:, content:)
+      @type = type&.to_sym
+      @content = content
+      freeze
+    end
+
+    # @return [Symbol, nil]
+    attr_reader :type
+    # @return [String, Proc, nil]
+    attr_reader :content
+
+    # Stringified content.
+    #
+    # @return [String]
+    def to_s
+      return @content.call.to_s if @content.is_a?(::Proc)
+
+      @content.to_s
+    end
+
+    alias string_content to_s
+  end
+end

data/lib/amber_component/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ::AmberComponent
+  VERSION = '0.0.2'
+end

data/lib/amber_component.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'rails'
+require 'active_support'
+require 'active_support/core_ext'
+
+module ::AmberComponent
+  class Error < ::StandardError; end
+  class ViewFileNotFound < Error; end
+  class InvalidType < Error; end
+
+  class EmptyView < Error; end
+  class UnknownViewType < Error; end
+  class MultipleViews < Error; end
+
+  class EmptyStyle < Error; end
+  class UnknownStyleType < Error; end
+  class MultipleStyles < Error; end
+end
+
+require_relative 'amber_component/version'
+require_relative 'amber_component/helper'
+require_relative 'amber_component/typed_content'
+require_relative 'amber_component/base'

data/sig/amber_components.rbs

@@ -0,0 +1,4 @@
+module AmberComponent
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end