amber_component 0.0.2 → 0.0.4

data/lib/amber_component/props.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative 'prop_definition'
+
+module ::AmberComponent
+  # Provides a DSL for defining component
+  # properties.
+  module Props
+    # Class methods for component properties.
+    module ClassMethods
+      # @return [Hash{Symbol => AmberComponent::Prop}]
+      attr_reader :prop_definitions
+
+      # @param names [Array<Symbol>]
+      # @param type [Class, nil]
+      # @param required [Boolean]
+      # @param default [Object, Proc, nil]
+      # @param allow_nil [Boolean]
+      def prop(*names, type: nil, required: false, default: nil, allow_nil: false)
+        @prop_definitions ||= {}
+        include(@prop_methods_module = ::Module.new) if @prop_methods_module.nil?
+
+        names.each do |name|
+          @prop_definitions[name] = prop_def = PropDefinition.new(
+            name: name,
+            type: type,
+            required: required,
+            default: default,
+            allow_nil: allow_nil
+          )
+          raise IncorrectPropTypeError, <<~MSG unless type.nil? || type.is_a?(::Class)
+            `type` should be a class but received `#{type.inspect}` (`#{type.class}`)
+          MSG
+
+          @prop_methods_module.attr_reader name
+          next @prop_methods_module.attr_writer(name) unless prop_def.type?
+
+          @prop_methods_module.class_eval( # rubocop:disable Style/DocumentDynamicEvalDefinition
+            # def phone=(val)
+            #   raise IncorrectPropTypeError, <<~MSG unless val.nil? || val.is_a?(String)
+            #     #{self.class} received `#{val.class}` instead of `String` for `phone` prop
+            #   MSG
+            #
+            #   @phone = val
+            # end
+            <<~RUB, __FILE__, __LINE__ + 1
+              def #{name}=(val)
+                raise IncorrectPropTypeError, <<~MSG unless #{allow_nil ? 'val.nil? ||' : nil} val.is_a?(#{prop_def.type})
+                  \#{self.class} received `\#{val.class}` instead of `#{prop_def.type}` for `#{name}` prop
+                MSG
+
+                @#{name} = val
+              end
+            RUB
+          ) # rubocop:disable Layout/HeredocArgumentClosingParenthesis
+        end
+      end
+
+      # @return [Array<Symbol>, nil]
+      def prop_names
+        @prop_definitions.keys
+      end
+
+      # @return [Array<Symbol>, nil]
+      def required_prop_names
+        @prop_definitions&.filter_map do |name, prop_def|
+          next unless prop_def.required
+
+          name
+        end
+      end
+    end
+
+    # Instance methods for component properties.
+    module InstanceMethods
+      private
+
+      # @param props [Hash{Symbol => Object}]
+      def initialize(**kwargs)
+        bind_props(kwargs)
+      end
+
+      # @param props [Hash{Symbol => Object}]
+      # @return [Boolean] `false` when there are no props defined on the class
+      #   and `true` otherwise
+      # @raise [AmberComponent::MissingPropsError] when required props are missing
+      # @raise [AmberComponent::IncorrectPropTypeError]
+      def bind_props(props)
+        return false if self.class.prop_definitions.nil?
+
+        self.class.prop_definitions.each do |name, prop_def|
+          setter_name = :"#{name}="
+          public_send(setter_name, prop_def.default!) if prop_def.default?
+
+          prop_present = props.include? name
+
+          raise MissingPropsError, <<~MSG if prop_def.required? && !prop_present
+            `#{self.class}` has a missing required prop: `#{name.inspect}`
+          MSG
+
+          next unless prop_present
+
+          value = props[name]
+          public_send(setter_name, value)
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/amber_component/railtie.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ::AmberComponent
+  # Class which hooks into Rails
+  # and configures the application.
+  class Railtie < ::Rails::Railtie
+    initializer 'amber_component.initialization' do |app|
+      app.config.assets.paths << (app.root / 'app' / 'components')
+
+      next if ::Rails.env.production?
+
+      components_root = app.root / 'app' / 'components'
+      component_paths = ::Dir[components_root / '**' / '*.rb']
+      app.config.eager_load_paths += component_paths
+
+      ::ActiveSupport::Reloader.to_prepare do
+        component_paths.each { |file| require_dependency(components_root / file) }
+      end
+    end
+  end
+end

data/lib/amber_component/rendering.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ::AmberComponent
+  # Provides universal methods for rendering components.
+  module Rendering
+    # Class methods for rendering.
+    module ClassMethods
+      # @param kwargs [Hash{Symbol => Object}]
+      # @return [String]
+      def render(**kwargs, &block)
+        comp = new(**kwargs)
+
+        comp.render(&block)
+      end
+
+      alias call render
+    end
+
+    # Instance methods for rendering.
+    module InstanceMethods
+      # @return [String]
+      def render(&block)
+        run_callbacks :render do
+          element  = render_view(&block)
+          # styles   = inject_styles
+          # element += styles unless styles.nil?
+          element.html_safe
+        end
+      end
+
+      # Method used internally by Rails to render an object
+      # passed to the `render` method.
+      #
+      #   render MyComponent.new(some: :attribute)
+      #
+      # @param _context [ActionView::Base]
+      # @return [String]
+      def render_in(_context)
+        render
+      end
+
+      protected
+
+      # @param content [String]
+      # @param type [Symbol]
+      # @param block [Proc, nil]
+      # @return [String]
+      def render_string(content, type, block = nil)
+        TemplateHandler.render_from_string(self, content, type, block)
+      end
+    end
+  end
+end

data/lib/amber_component/template_handler/erb.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'action_view'
+require 'ostruct'
+
+module ::AmberComponent
+  module TemplateHandler
+    # Handles rendering ERB with Rails-like syntax
+    class ERB < ::ActionView::Template::Handlers::ERB::Erubi
+      def initialize(input, properties = {})
+        properties[:bufvar] ||= "@output_buffer"
+        properties[:preamble] = "#{properties[:bufvar]}=#{::ActionView::OutputBuffer}.new;"
+        super
+      end
+    end
+  end
+end

data/lib/amber_component/template_handler.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ::AmberComponent
+  # Provides code which handles rendering different
+  # template languages.
+  module TemplateHandler
+    class << self
+      # @param context [AmberComponent::Base]
+      # @param content [String]
+      # @param type [Symbol, String]
+      # @param block [Proc, nil]
+      # @return [String]
+      def render_from_string(context, content, type, block = nil)
+        options = if type.to_sym == :erb
+                    { engine_class: ERB }
+                  else
+                    {}
+                  end
+
+        ::Tilt[type].new(options) { content }.render(context, &block)
+      end
+    end
+  end
+end
+
+require_relative 'template_handler/erb'

data/lib/amber_component/typed_content.rb

@@ -9,9 +9,9 @@ module ::AmberComponent
       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
+        raise InvalidTypeError, <<~MSG unless val.respond_to?(:[])
+          `TypedContent` should be a `Hash` or `#{self}` but was `#{val.class}` (#{val.inspect})
+        MSG
 
         new(type: val[:type], content: val[:content])
       end

data/lib/amber_component/version.rb

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

data/lib/amber_component/views.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module ::AmberComponent
+  # Provides methods concerning view registering and rendering.
+  module Views
+    # 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 [Regexp]
+    VIEW_FILE_REGEXP  = /^view\./.freeze
+
+    # Class methods for views.
+    module ClassMethods
+      # 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
+
+      # @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 MultipleViewsError, "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..].grep_v(/erb/).last || 'erb')&.to_sym
+      end
+    end
+
+    # Instance methods for views.
+    module InstanceMethods
+      protected
+
+      # @return [String]
+      def render_view(&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 ViewFileNotFoundError, "View for `#{self.class}` could not be found!"
+        end
+
+        view_content
+      end
+
+      # Helper method to render view from string or with other provided type.
+      #
+      # Usage:
+      #
+      #   render_view_from_content('<h1>Hello World</h1>')
+      #
+      # or:
+      #
+      #   render_view_from_content content: '**Hello World**', type: 'md'
+      #
+      # @param content [TypedContent, Hash{Symbol => String, Symbol, Proc}, String]
+      # @return [String, nil]
+      def render_view_from_content(content, &block)
+        return '' unless content
+        return content if content.is_a?(::String)
+
+        content = TypedContent.wrap(content)
+        type = content.type
+        content = content.to_s
+
+        if content.empty?
+          raise EmptyViewError, <<~ERR.squish
+            Custom view for `#{self.class}` from view method cannot be empty!
+          ERR
+        end
+
+        unless ALLOWED_VIEW_TYPES.include? type
+          raise UnknownViewTypeError, <<~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_view_from_content(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_view_from_content(data, &block)
+      end
+    end
+  end
+end

data/lib/amber_component.rb

@@ -1,24 +1,27 @@
 # 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 MissingPropsError < Error; end
+  class IncorrectPropTypeError < Error; end
+  class ViewFileNotFoundError < Error; end
+  class InvalidTypeError < 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
+  class EmptyViewError < Error; end
+  class UnknownViewTypeError < Error; end
+  class MultipleViewsError < Error; end
 end
 
 require_relative 'amber_component/version'
-require_relative 'amber_component/helper'
+require_relative 'amber_component/helpers'
 require_relative 'amber_component/typed_content'
+require_relative 'amber_component/template_handler'
+require_relative 'amber_component/views'
+require_relative 'amber_component/assets'
+require_relative 'amber_component/rendering'
+require_relative 'amber_component/props'
 require_relative 'amber_component/base'
+require_relative 'amber_component/railtie' if defined?(::Rails::Railtie)

data/lib/generators/amber_component/install_generator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module ::AmberComponent
+  module Generators
+    # A Rails generator which installs the `amber_component`
+    # library in a Rails project.
+    class InstallGenerator < ::Rails::Generators::Base
+      desc 'Install the AmberComponent gem'
+      source_root ::File.expand_path('templates', __dir__)
+
+      # copy rake tasks
+      def copy_tasks
+        copy_file 'application_component.rb', 'app/components/application_component.rb'
+
+        inject_into_file 'app/assets/stylesheets/application.css', after: "*= require_tree .\n" do
+          " *= require_tree ./../../components\n"
+        end
+      end
+    end
+  end
+end

data/lib/generators/amber_component/templates/application_component.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Abstract class which should serve as a superclass
+# for all your custom components in this app.
+#
+# @abstract Subclass to create a new component.
+class ::ApplicationComponent < ::AmberComponent::Base
+  # Include your global application helper.
+  include ::ApplicationHelper
+  # Include the helper methods for your application's
+  # routes.
+  include ::Rails.application.routes.url_helpers
+end

data/lib/generators/amber_component_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+# A Rails generator which creates a new Amber component.
+class AmberComponentGenerator < ::Rails::Generators::NamedBase
+  desc 'Generate a new component'
+  source_root ::File.expand_path('templates', __dir__)
+
+  # copy rake tasks
+  def copy_tasks
+    template 'component.rb.erb', "app/components/#{file_path}.rb"
+    template 'component_test.rb.erb', "test/components/#{file_path}_test.rb"
+    template 'view.html.erb', "app/components/#{file_path}/view.html.erb"
+    template 'style.css.erb', "app/components/#{file_path}/style.css"
+  end
+
+  def file_name
+    name = super
+    return name if name.end_with? '_component'
+
+    "#{name}_component"
+  end
+end

data/lib/generators/templates/component.rb.erb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class <%= class_name %> < ::ApplicationComponent
+  # Your code goes here
+
+  after_initialize do
+    @time = ::Time.now
+  end
+end

data/lib/generators/templates/component_test.rb.erb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class <%= class_name %>Test < ::ActiveSupport::TestCase
+  # test 'the truth' do
+  #   assert true
+  # end
+end

data/lib/generators/templates/style.css.erb

@@ -0,0 +1,3 @@
+.<%= singular_table_name %> {
+  color: blue;
+}

data/lib/generators/templates/view.html.erb

@@ -0,0 +1,3 @@
+<h2 class='<%= singular_table_name %>'>
+  Hello from <b><%= class_name %></b>, initialized at: <%%= @time %>
+</h2>