elemental_components 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8724d56949364ada3c44e3db2924edb30ea0c4d3929295fc7d0a683a576b2089
+  data.tar.gz: d7c2d081abf83dbf6e42e68a3eca26ab186dec2f446380a5a94b0a7ec5634857
+SHA512:
+  metadata.gz: a619164930556d15e744814440632e2a44afabcce5ffefafbe99e8d2c5d88883b9e9e849ec4595ddd8d6a8fbf921d89ebc097a098efd084f6e63237abd67c15a
+  data.tar.gz: 96dfa689ebbb64c40ca722bc9656a45ba27951e0824318f9da114932314652150c47ec4983434a2b3f0efaf58bbf1289e6a3c59a2e1b83aaeee343d36264e0c6

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Jens Ljungblad
+
+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,483 @@
+# Elemental Components
+
+Simple view components for Rails 5.1+, designed to go well with [elemental_styleguide](https://github.com/jensljungblad/elemental_styleguide). The two together are inspired by the works of [Brad Frost](http://bradfrost.com) and by the [thoughts behind](http://engineering.lonelyplanet.com/2014/05/18/a-maintainable-styleguide.html) Lonely Planet's style guide [Rizzo](http://rizzo.lonelyplanet.com).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "elemental_components"
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+## Components
+
+The examples provided here will use the [BEM naming conventions](http://getbem.com/naming/).
+
+Components live in `app/components`. Generate a component by executing:
+
+```sh
+$ bin/rails g elemental_components:component alert
+```
+
+This will create the following files:
+
+```
+app/
+  components/
+    alert/
+      _alert.html.erb
+      alert.css
+      alert.js
+    alert_component.rb
+```
+
+The generator also takes `--skip-css` and `--skip-js` options.
+
+Let's add some markup and CSS:
+
+```erb
+<% # app/components/alert/_alert.html.erb %>
+
+<div class="alert alert--primary" role="alert">
+  Message
+</div>
+```
+
+```css
+/* app/components/alert/alert.css */
+
+.alert {
+  padding: 1rem;
+}
+
+.alert--primary {
+  background: blue;
+}
+
+.alert--success {
+  background: green;
+}
+
+.alert--danger {
+  background: red;
+}
+```
+
+This component can now be rendered using the `component` helper:
+
+```erb
+<%= component "alert" %>
+```
+
+### Assets
+
+In order to require assets such as CSS, either require them manually in the manifest, e.g. `application.css`:
+
+```css
+/*
+ *= require alert/alert
+ */
+```
+
+Or require `components`, which will in turn require the assets for all components:
+
+```css
+/*
+ *= require elemental_components
+ */
+```
+
+### Attributes and blocks
+
+There are two ways of passing data to components: attributes and blocks. Attributes are useful for data such as ids, modifiers and data structures (models etc). Blocks are useful when you need to inject HTML content into components.
+
+Let's define some attributes for the component we just created:
+
+```ruby
+# app/components/alert_component.rb %>
+
+class AlertComponent < ElementalComponents::Component
+  attribute :context
+  attribute :message
+end
+```
+
+```erb
+<% # app/components/alert/_alert.html.erb %>
+
+<div class="alert alert--<%= alert.context %>" role="alert">
+  <%= alert.message %>
+</div>
+```
+
+```erb
+<%= component "alert", message: "Something went right!", context: "success" %>
+<%= component "alert", message: "Something went wrong!", context: "danger" %>
+```
+
+To inject some text or HTML content into our component we can print the component variable in our template, and populate it by passing a block to the component helper:
+
+```erb
+<% # app/components/alert/_alert.html.erb %>
+
+<div class="alert alert--<%= alert.context %>" role="alert">
+  <%= alert %>
+</div>
+```
+
+```erb
+<%= component "alert", context: "success" do %>
+  <em>Something</em> went right!
+<% end %>
+```
+
+Another good use case for attributes is when you have a component backed by a model:
+
+```ruby
+# app/components/comment_component.rb %>
+
+class CommentComponent < ElementalComponents::Component
+  attribute :comment
+
+  delegate :id,
+           :author,
+           :body, to: :comment
+end
+```
+
+```erb
+<% # app/components/comment/_comment.html.erb %>
+
+<div id="comment-<%= comment.id %>" class="comment">
+  <div class="comment__author">
+    <%= link_to comment.author.name, author_path(comment.author) %>
+  </div>
+  <div class="comment__body">
+    <%= comment.body %>
+  </div>
+</div>
+```
+
+```erb
+<% comments.each do |comment| %>
+  <%= component "comment", comment: comment %>
+<% end %>
+```
+
+### Attribute defaults
+
+Attributes can have default values:
+
+```ruby
+# app/components/alert_component.rb %>
+
+class AlertComponent < ElementalComponents::Component
+  attribute :message
+  attribute :context, default: "primary"
+end
+```
+
+### Attribute overrides
+
+It's easy to override an attribute with additional logic:
+
+```ruby
+# app/components/alert_component.rb %>
+
+class AlertComponent < ElementalComponents::Component
+  attribute :message
+  attribute :context, default: "primary"
+
+  def message
+    @message.upcase if context == "danger"
+  end
+end
+```
+
+### Attribute validation
+
+To ensure your components get initialized properly you can use `ActiveModel::Validations` in your elements or components:
+
+```ruby
+# app/components/alert_component.rb %>
+
+class AlertComponent < ElementalComponents::Component
+  attribute :label
+
+  validates :label, presence: true
+end
+```
+
+Your validations will be executed during the components initialization and raise an `ActiveModel::ValidationError` if any validation fails.
+
+### Elements
+
+Attributes and blocks are great for simple components or components backed by a data structure, such as a model. Other components are more generic in nature and can be used in a variety of contexts. Often they consist of multiple parts or elements, that sometimes repeat, and sometimes need their own modifiers.
+
+Take a card component. In React, a common approach is to create subcomponents:
+
+```jsx
+<Card flush={true}>
+  <CardHeader centered={true}>
+    Header
+  </CardHeader>
+  <CardSection size="large">
+    Section 1
+  </CardSection>
+  <CardSection size="small">
+    Section 2
+  </CardSection>
+  <CardFooter>
+    Footer
+  </CardFooter>
+</Card>
+```
+
+There are two problems with this approach:
+
+1. The card header, section and footer have no standalone meaning, yet we treat them as standalone components. This means a `CardHeader` could be placed outside of a `Card`.
+2. We lose control of the structure of the elements. A `CardHeader` can be placed below, or inside a `CardFooter`.
+
+Using this gem, the same component can be written like this:
+
+```ruby
+# app/components/card_component.rb %>
+
+class CardComponent < ElementalComponents::Component
+  attribute :flush, default: false
+
+  element :header do
+    attribute :centered, default: false
+  end
+
+  element :section, multiple: true do
+    attribute :size
+  end
+
+  element :footer
+end
+```
+
+```erb
+<% # app/components/card/_card.html.erb %>
+
+<div class="card <%= "card--flush" if card.flush %>">
+  <div class="card__header <%= "card__header--centered" if card.header.centered %>">
+    <%= card.header %>
+  </div>
+  <% card.sections.each do |section| %>
+    <div class="card__section <%= "card__section--#{section.size}" %>">
+      <%= section %>
+    </div>
+  <% end %>
+  <div class="card__footer">
+    <%= card.footer %>
+  </div>
+</div>
+```
+
+Elements can be thought of as isolated subcomponents, and they are defined on the component. Passing `multiple: true` makes it a repeating element, and passing a block lets us declare attributes on our elements, in the same way we declare attributes on components.
+
+In order to populate them with data, we pass a block to the component helper, which yields the component, which lets us set attributes and blocks on the element in the same way we do for components:
+
+```erb
+<%= component "card", flush: true do |c| %>
+  <% c.header centered: true do %>
+    Header
+  <% end %>
+  <% c.section size: "large" do %>
+    Section 1
+  <% end %>
+  <% c.section size: "large" do %>
+    Section 2
+  <% end %>
+  <% c.footer do %>
+    Footer
+  <% end %>
+<% end %>
+```
+
+Multiple calls to a repeating element, such as `section` in the example above, will append each section to an array.
+
+Another good use case is a navigation component:
+
+```ruby
+# app/components/navigation_component.rb %>
+
+class NavigationComponent < ElementalComponents::Component
+  element :items, multiple: true do
+    attribute :label
+    attribute :url
+    attribute :active, default: false
+  end
+end
+```
+
+```erb
+<%= component "navigation" do |c| %>
+  <% c.item label: "Home", url: root_path, active: true %>
+  <% c.item label: "Explore" url: explore_path %>
+<% end %>
+```
+
+An alternative here is to pass a data structure to the component as an attribute, if no HTML needs to be injected when rendering the component:
+
+```erb
+<%= component "navigation", items: items %>
+```
+
+Elements can have validations, too:
+
+```ruby
+class NavigationComponent < ElementalComponents::Component
+  element :items, multiple: true do
+    attribute :label
+    attribute :url
+    attribute :active, default: false
+
+    validates :label, presence: true
+    validates :url, presence: true
+  end
+end
+```
+
+Elements can also be nested, although it is recommended to keep nesting to a minimum:
+
+```ruby
+# app/components/card_component.rb %>
+
+class CardComponent < ElementalComponents::Component
+  ...
+
+  element :section, multiple: true do
+    attribute :size
+
+    element :header
+    element :footer
+  end
+end
+```
+
+### Helper methods
+
+In addition to declaring attributes and elements, it is also possible to declare helper methods. This is useful if you prefer to keep logic out of your templates. Let's extract the modifier logic from the card component template:
+
+```ruby
+# app/components/card_component.rb %>
+
+class CardComponent < ElementalComponents::Component
+  ...
+
+  def css_classes
+    css_classes = ["card"]
+    css_classes << "card--flush" if flush
+    css_classes.join(" ")
+  end
+end
+```
+
+```erb
+<% # app/components/card/_card.html.erb %>
+
+<%= content_tag :div, class: card.css_classes do %>
+  ...
+<% end %>
+```
+
+It's even possible to declare helpers on elements:
+
+```ruby
+# app/components/card_component.rb %>
+
+class CardComponent < ElementalComponents::Component
+  ...
+
+  element :section, multiple: true do
+    attribute :size
+
+    def css_classes
+      css_classes = ["card__section"]
+      css_classes << "card__section--#{size}" if size
+      css_classes.join(" ")
+    end
+  end
+end
+```
+
+```erb
+<% # app/components/card/_card.html.erb %>
+
+<%= content_tag :div, class: card.css_classes do %>
+  ...
+  <%= content_tag :div, class: section.css_classes do %>
+    <%= section %>
+  <% end %>
+  ...
+<% end %>
+```
+
+Helper methods can also make use of the `@view` instance variable in order to call Rails helpers such as `link_to` or `content_tag`.
+
+### Rendering components without a partial
+
+For some small components, such as buttons, it might make sense to skip the partial altogether, in order to speed up rendering. This can be done by overriding `render` on the component:
+
+```ruby
+# app/components/button_component.rb %>
+
+class ButtonComponent < ElementalComponents::Component
+  attribute :label
+  attribute :url
+  attribute :context
+
+  def render
+    @view.link_to label, url, class: css_classes
+  end
+
+  def css_classes
+    css_classes = "button"
+    css_classes << "button--#{context}" if context
+    css_classes.join(" ")
+  end
+end
+```
+
+```erb
+<%= component "button", label: "Sign up", url: sign_up_path, context: "primary" %>
+<%= component "button", label: "Sign in", url: sign_in_path %>
+```
+
+### Namespaced components
+
+Components can be nested under a namespace. This is useful if you want to practice things like [Atomic Design](http://bradfrost.com/blog/post/atomic-web-design/), [BEMIT](https://csswizardry.com/2015/08/bemit-taking-the-bem-naming-convention-a-step-further/) or any other component classification scheme. In order to create a namespaced component, stick it in a folder and wrap the class in a module:
+
+```ruby
+module Objects
+  class MediaObject < ElementalComponents::Component; end
+end
+```
+
+Then call it from a template like so:
+
+```erb
+<%= component "objects/media_object" %>
+```
+
+## Acknowledgements
+
+This library, together with [elemental_styleguide](https://github.com/jensljungblad/elemental_styleguide), was inspired by the writings of [Brad Frost](http://bradfrost.com) on atomic design and living style guides, and [Rizzo](http://rizzo.lonelyplanet.com), the Lonely Planet style guide. Other inspirations were:
+
+- [Catalog](https://www.catalog.style) - style guide for React
+- [Storybook](https://storybook.js.org) - style guide for React
+- [React Styleguidist](https://react-styleguidist.js.org) - style guide for React
+- [Cells](https://github.com/trailblazer/cells) - view components for Ruby
+- [Komponent](https://github.com/komposable/komponent) - view components for Ruby
+
+For a list of real world style guides, check out http://styleguides.io.

data/Rakefile

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+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    = "Elemental Components"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+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/app/assets/config/elemental_components_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/elemental_components .js
+//= link_directory ../stylesheets/elemental_components .css

data/app/assets/javascripts/elemental_components.js.erb

@@ -0,0 +1,7 @@
+<% ElementalComponents.component_names.each do |name| %>
+  <% begin %>
+    <% require_asset "#{name}/#{name.split('/')[-1]}" %>
+  <% rescue Sprockets::FileNotFound %>
+    <% Rails.logger.debug "ElementalComponents: JS not found for #{name}" %>
+  <% end %>
+<% end %>

data/app/assets/stylesheets/elemental_components.css.erb

@@ -0,0 +1,7 @@
+<% ElementalComponents.component_names.each do |name| %>
+  <% begin %>
+    <% require_asset "#{name}/#{name.split('/')[-1]}" %>
+  <% rescue Sprockets::FileNotFound %>
+    <% Rails.logger.debug "ElementalComponents: CSS not found for #{name}" %>
+  <% end %>
+<% end %>

data/app/helpers/elemental_components/component_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ElementalComponents
+  module ComponentHelper
+    def component(name, attrs = nil, &block)
+      "#{name}_component".classify.constantize.new(self, attrs, &block).render
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+ElementalComponents::Engine.routes.draw do
+end

data/lib/elemental_components.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "elemental_components/element"
+require "elemental_components/component"
+require "elemental_components/engine"
+
+module ElementalComponents
+  class Error < StandardError; end
+
+  def self.components_path
+    Rails.root.join("app", "components")
+  end
+
+  def self.component_names
+    Dir.chdir(components_path) do
+      Dir.glob("**/*_component.rb").map { |component| component.chomp("_component.rb") }.sort
+    end
+  end
+end

data/lib/elemental_components/component.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ElementalComponents
+  class Component < Element
+    def self.model_name
+      ActiveModel::Name.new(ElementalComponents::Component)
+    end
+
+    def self.component_name
+      name.chomp("Component").demodulize.underscore
+    end
+
+    def self.component_path
+      name.chomp("Component").underscore
+    end
+
+    def render
+      @view.render partial: to_partial_path, object: self
+    end
+
+    def to_partial_path
+      [self.class.component_path, self.class.component_name].join("/")
+    end
+  end
+end

data/lib/elemental_components/element.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ElementalComponents
+  class Element
+    include ActiveModel::Validations
+
+    def self.model_name
+      ActiveModel::Name.new(ElementalComponents::Element)
+    end
+
+    def self.attributes
+      @attributes ||= {}
+    end
+
+    def self.attribute(name, default: nil)
+      attributes[name] = { default: default }
+
+      define_method_or_raise(name) do
+        get_instance_variable(name)
+      end
+    end
+
+    def self.elements
+      @elements ||= {}
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/PerceivedComplexity
+    def self.element(name, multiple: false, &config)
+      plural_name = name.to_s.pluralize.to_sym if multiple
+
+      elements[name] = {
+        multiple: plural_name || false, class: Class.new(Element, &config)
+      }
+
+      define_method_or_raise(name) do |attributes = nil, &block|
+        return get_instance_variable(multiple ? plural_name : name) unless attributes || block
+
+        element = self.class.elements[name][:class].new(@view, attributes, &block)
+
+        if multiple
+          get_instance_variable(plural_name) << element
+        else
+          set_instance_variable(name, element)
+        end
+      end
+
+      return if !multiple || name == plural_name
+
+      define_method_or_raise(plural_name) do
+        get_instance_variable(plural_name)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def self.define_method_or_raise(method_name, &block)
+      if method_defined?(method_name.to_sym)
+        raise(ElementalComponents::Error, "Method '#{method_name}' already exists.")
+      end
+
+      define_method(method_name, &block)
+    end
+    private_class_method :define_method_or_raise
+
+    def initialize(view, attributes = nil, &block)
+      @view = view
+      initialize_attributes(attributes || {})
+      initialize_elements
+      @yield = block_given? ? @view.capture(self, &block) : nil
+      validate!
+    end
+
+    def to_s
+      @yield
+    end
+
+    protected
+
+    def initialize_attributes(attributes)
+      self.class.attributes.each do |name, options|
+        set_instance_variable(name, attributes[name] || (options[:default] && options[:default].dup))
+      end
+    end
+
+    def initialize_elements
+      self.class.elements.each do |name, options|
+        if (plural_name = options[:multiple])
+          set_instance_variable(plural_name, [])
+        else
+          set_instance_variable(name, nil)
+        end
+      end
+    end
+
+    private
+
+    def get_instance_variable(name)
+      instance_variable_get(:"@#{name}")
+    end
+
+    def set_instance_variable(name, value)
+      instance_variable_set(:"@#{name}", value)
+    end
+  end
+end

data/lib/elemental_components/engine.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ElementalComponents
+  class Engine < ::Rails::Engine
+    isolate_namespace ElementalComponents
+
+    initializer "elemental_components.asset_paths" do |app|
+      app.config.assets.paths << ElementalComponents.components_path if app.config.respond_to?(:assets)
+    end
+
+    initializer "elemental_components.view_helpers" do
+      ActiveSupport.on_load :action_controller do
+        helper ElementalComponents::ComponentHelper
+      end
+    end
+
+    initializer "elemental_components.view_paths" do
+      ActiveSupport.on_load :action_controller do
+        append_view_path ElementalComponents.components_path
+      end
+    end
+  end
+end

data/lib/elemental_components/railtie.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ElementalComponents
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/elemental_components/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ElementalComponents
+  VERSION = "1.0.0.rc1"
+end

data/lib/generators/elemental_components/component_generator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ElementalComponents
+  class ComponentGenerator < Rails::Generators::NamedBase
+    desc "Generate a component"
+    class_option :skip_erb, type: :boolean, default: false
+    class_option :skip_css, type: :boolean, default: false
+    class_option :skip_js, type: :boolean, default: false
+
+    source_root File.expand_path("templates", __dir__)
+
+    def create_component_file
+      template "component.rb.erb", "app/components/#{name}_component.rb"
+    end
+
+    def create_erb_file
+      return if options["skip_erb"]
+
+      create_file "app/components/#{name}/_#{filename}.html.erb"
+    end
+
+    def create_css_file
+      return if options["skip_css"]
+
+      create_file "app/components/#{name}/#{filename}.css"
+    end
+
+    def create_js_file
+      return if options["skip_js"]
+
+      create_file "app/components/#{name}/#{filename}.js"
+    end
+
+    private
+
+    def filename
+      name.split("/").last
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+class <%= name.classify %>Component < ElementalComponents::Component
+end

data/lib/tasks/elemental_components_tasks.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# desc "Explaining what the task does"
+# task :elemental_components do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: elemental_components
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Jens Ljungblad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.74.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.74.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+description: Simple view components for Rails 5.1+
+email:
+- jens.ljungblad@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/elemental_components_manifest.js
+- app/assets/javascripts/elemental_components.js.erb
+- app/assets/stylesheets/elemental_components.css.erb
+- app/helpers/elemental_components/component_helper.rb
+- config/routes.rb
+- lib/elemental_components.rb
+- lib/elemental_components/component.rb
+- lib/elemental_components/element.rb
+- lib/elemental_components/engine.rb
+- lib/elemental_components/railtie.rb
+- lib/elemental_components/version.rb
+- lib/generators/elemental_components/component_generator.rb
+- lib/generators/elemental_components/templates/component.rb.erb
+- lib/tasks/elemental_components_tasks.rake
+homepage: https://www.github.com/jensljungblad/elemental_components
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Simple view components for Rails 5.1+
+test_files: []