rack-component 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4a43f4454b5d988c4745d26c61bb46b8cbe21e56e3aa74d6b84427d4f110ab7
-  data.tar.gz: f49b907249aef3ebc79c5168c785eeb7ea977152c41278896e5cd4432467f2c5
+  metadata.gz: 441fd93e02f16449c7284aa7c84b72d01bc8b87e133999c2ed4b7a637431be07
+  data.tar.gz: ab7f5669c4b28c991f173180597f7b94c64de8cc8158d31da18f60b3927010f8
 SHA512:
-  metadata.gz: a48bcaf0c62f6d83071d6a99ce5517898d28d498dc8f23ef61392641ea7a71a6b921f8f65521f35c4c79a001c90978594a9d439f4e9ab67dc0094840b43cfafb
-  data.tar.gz: 87cd31cacc2c95b330e68cc07574f586c45777c69b0e4c5b6810fba0ff8325f4cb85b467fb718d35a201b3cbb7a09cf816c3ea7d2e05e5f0059d532c100e15be
+  metadata.gz: 3232586822a9c38192cdbab6aa537236a331334ec0fe5ccaefbcdb8a62be92617f9fa94c4f372dbefc6eed92d0a8ef34e4c91971c6ef8b5f211bfede3d52b470
+  data.tar.gz: dbe6b3663319d39bf6ebf5c5610979a5de5713ec992dfe6dc5f5f680bd7c551ed540036addf317fdd08c93756259a4deda97a49b224dbe8ec3b28fe593574c88

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rack-component (0.2.0)
+    rack-component (0.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -12,8 +12,6 @@ GEM
       ice_nine (~> 0.11.0)
       thread_safe (~> 0.3, >= 0.3.1)
     benchmark-ips (2.7.2)
-    childprocess (0.9.0)
-      ffi (~> 1.0, >= 1.0.11)
     codeclimate-engine-rb (0.4.1)
       virtus (~> 1.0)
     coderay (1.1.2)
@@ -23,16 +21,11 @@ GEM
       thread_safe (~> 0.3, >= 0.3.1)
     diff-lcs (1.3)
     equalizer (0.0.11)
-    ffi (1.9.25)
     ice_nine (0.11.2)
-    iniparse (1.4.4)
     jaro_winkler (1.5.1)
     kwalify (0.7.2)
     method_source (0.9.0)
     mustermann (1.0.3)
-    overcommit (0.46.0)
-      childprocess (~> 0.6, >= 0.6.3)
-      iniparse (~> 1.4)
     parallel (1.12.1)
     parser (2.5.1.2)
       ast (~> 2.4.0)
@@ -95,7 +88,6 @@ PLATFORMS
 DEPENDENCIES
   benchmark-ips (~> 2.7)
   bundler (~> 1.16)
-  overcommit (~> 0)
   pry (~> 0.11)
   rack-component!
   rack-test (~> 0)

data/README.md

@@ -1,8 +1,10 @@
 # Rack::Component
 
-Like a React.js component, a `Rack::Component` implements a `render` method that takes input data and returns what to display.
+Like a React.js component, a `Rack::Component` implements a `render` method that
+takes input data and returns what to display.
 
-You can combine Components to build complex features out of simple, easily testable units.
+You can combine Components to build complex features out of simple, easily
+testable units.
 
 ## Installation
 
@@ -21,99 +23,103 @@ Or install it yourself as:
     $ gem install rack-component
 
 ## API Reference
-Please see the [YARD docs on rubydoc.info](https://www.rubydoc.info/gems/rack-component)
 
-## Usage
+Please see the
+[YARD docs on rubydoc.info](https://www.rubydoc.info/gems/rack-component)
 
-You could build an entire app out of Components, but Ruby already has great HTTP routers like [Roda][roda] and [Sinatra][sinatra]. Here's an example that uses Sinatra for routing, and Components instead of views, controllers, and templates.
+## Usage
 
-### With Sinatra
+Subclass `Rack::Component` and `#call` it:
 
 ```ruby
-get '/posts/:id' do
-  PostFetcher.call(id: params[:id]) do |post|
-    Layout.call(title: post[:title]) do
-      PostView.call(post)
-    end
-  end
+require 'rack/component'
+class Useless < Rack::Component
 end
+
+Useless.call #=> the output Useless.new.render
 ```
 
-_Why_, you may be thinking, _would I write something so ugly when I could write this instead?_
+The default implementation of `#render` is to yield the component instance to
+whatever block you pass to `Component.call`, like this:
 
 ```ruby
-get '/posts/:id' do
-  @post = Post.find(params[:id])
-  @title = @post[:title]
-  erb :post
+Useless.call { |instance| "Hello from #{instance}" }
+#=> "Hello from #<Useless:0x00007fcaba87d138>"
+
+Useless.call do |instance|
+  Useless.call do |second_instance|
+    <<~HTML
+      <h1>Hello from #{instance}</h1>
+      <p>And also from #{second_instance}"</p>
+    HTML
+  end
 end
+# =>
+# <h1>Hello from #<Useless:0x00007fcaba87d138></h1>
+# <p>And also from #<Useless:0x00007f8482802498></p>
 ```
 
-You'd be right that the traditional version is shorter and pretter. But the Component version’s API is more declarative -- you are describing what you want, and leaving the details of _how to get it_ up to each Component, instead of writing implementation-specific details right in your route block.
+### Implement `#render` or add instance methods to make Components do work
 
-The Component version is easier to reuse, refactor, and test. And because Components are meant to be combined via composition, it's actually trivial to make a Component version that's even more concise:
+Peruse the [specs][specs] for examples of component chains that handle
+data fetching, views, and error handling in Sinatra and raw Rack.
+
+Here's a component chain that prints headlines from Daring Fireball’s JSON feed:
 
 ```ruby
-get('/posts/:id') do
-  PostPageView.call(id: params[:id])
-end
+require 'rack/component'
+
+# Make a network request and return the response
+class Fetcher < Rack::Component
+  require 'net/http'
+  def initialize(uri:)
+    @response = Net::HTTP.get(URI(uri))
+  end
 
-# Compose a few Components to save on typing
-class PostPageView < Rack::Component
   def render
-    PostFetcher.call(id: props[:id]) do |post|
-      Layout.call(title: post[:title]) { PostView.call(post) }
-    end
+    yield @response
   end
 end
-```
 
-PostFetcher, Layout, and PostView are all simple Rack::Components. Their implementation looks like this:
-
-```ruby
-require 'rack/component'
+# Parse items from a JSON Feed document
+class JSONFeedParser < Rack::Component
+  require 'json'
+  def initialize(data)
+    @items = JSON.parse(data).fetch('items')
+  end
 
-# render an HTML page
-class Layout < Rack::Component
   def render
-    %(
-      <html>
-        <head>
-          <title>#{props[:title]}</title>
-        </head>
-        <body>
-          #{yield}
-        </body>
-      </html>
-    )
+    yield @items
   end
 end
 
-# Fetch a post, pass it to the next component
-class PostFetcher < Rack::Component
-  def render
-    yield fetch
+# Render an HTML list of posts
+class PostsList < Rack::Component
+  def initialize(posts:, style: '')
+    @posts = posts
+    @style = style
   end
 
-  def fetch
-    DB[:posts].fetch(props[:id].to_i)
+  def render
+    <<~HTML
+      <ul style="#{@style}">
+        #{@posts.map(&ListItem).join}"
+      </ul>
+    HTML
   end
-end
 
-# A fake database with a fake 'posts' table
-DB = { posts: { 1 => { title: 'Example Title', body: 'Example body' } } }
+  ListItem = ->(post) { "<li>#{post['title']}</li>" }
+end
 
-# View a single post
-class PostView < Rack::Component
-  def render
-    %(
-      <article>
-        <h1>#{props[:title]}</h1>
-        <p>#{props[:body]}</h1>
-      </article>
-    )
+# Fetch JSON Feed data from daring fireball, parse it, render a list
+Fetcher.call(uri: 'https://daringfireball.net/feeds/json') do |data|
+  JSONFeedParser.call(data) do |items|
+    PostsList.call(posts: items, style: 'background-color: red')
   end
 end
+end
+#=> A <ul> full of headlines from Daring Fireball
+
 ```
 
 ## Development
@@ -137,5 +143,4 @@ https://github.com/chrisfrank/rack-component.
 
 MIT
 
-[roda]: https://github.com/jeremyevans/roda
-[sinatra]: https://github.com/sinatra/sinatra
+[specs]: https://github.com/chrisfrank/rack-component/tree/master/spec

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'chemical'
+require 'rack/component'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/lib/rack/component.rb

@@ -1,50 +1,54 @@
 require_relative 'component/component_cache'
+require_relative 'component/refinements'
 
 module Rack
   # Subclass Rack::Component to compose declarative, component-based responses
   # to HTTP requests
   class Component
-    VERSION = '0.2.0'.freeze
+    VERSION = '0.3.0'.freeze
 
-    EMPTY = ''.freeze # components render an empty body by default
-    attr_reader :props
-
-    # Initialize a new component with the given props and #render() it.
+    # Initialize a new component with the given args and render it.
     #
-    # @example render a HelloWorld component
+    # @example Render a HelloWorld component
     #   class HelloWorld < Rack::Component
-    #     def world
-    #       props[:world]
+    #     def initialize(name)
+    #       @name = name
     #     end
     #
-    #     def call
-    #       %(<h1>Hello #{world}</h1>)
+    #     def render
+    #       "<h1>Hello #{@name}</h1>"
     #     end
     #   end
     #
     #   MyComponent.call(world: 'Earth') #=> '<h1>Hello Earth</h1>'
     # @return [String, Object] the output of instance#render
-    def self.call(*props, &block)
-      new(*props).render(&block)
-    end
-
-    def initialize(props = {})
-      @props = props
+    def self.call(*args, &block)
+      new(*args).render(&block)
     end
 
-    # Override call to make your component do work.
+    # Override either #render or #exposures to make your component do work.
+    # By default, the behavior of #render depends on whether you call the
+    # component with a block or not: it either returns #exposures or yields to
+    # the block with #exposures as arguments.
+    #
     # @return [String, Object] usually a string, but really whatever
     def render
-      block_given? ? yield(self) : EMPTY
+      block_given? ? yield(exposures) : exposures
+    end
+
+    # Override #exposures to keep the default yield-or-return behavior
+    # of #render, but change what gets yielded or returned
+    def exposures
+      self
     end
 
     # Rack::Component::Memoized is just like Component, only it
     # caches its rendered output in memory and only rerenders
-    # when called with new props.
+    # when called with new arguments.
     class Memoized < self
-      CACHE_SIZE = 100 # limit cache to 100 keys by default so we don't leak RAM
+      CACHE_SIZE = 100 # limit to 100 keys by default to prevent leaking RAM
 
-      # instantiate a class-level cache if necessary
+      # Access or instantiate a class-level cache
       # @return [Rack::Component::ComponentCache] a threadsafe in-memory cache
       def self.cache
         @cache ||= ComponentCache.new(const_get(:CACHE_SIZE))
@@ -52,37 +56,42 @@ module Rack
 
       # @example render a Memoized Component
       #   class Expensive < Rack::Component::Memoized
+      #     def initialize(id)
+      #       @id = id
+      #     end
+      #
       #     def work
       #       sleep 5
-      #       "#{props[:id]} was expensive"
+      #       "#{@id}"
       #     end
       #
-      #     def call
+      #     def render
       #       %(<h1>#{work}</h1>)
       #     end
       #   end
       #
       #   # first call takes five seconds
-      #   Expensive.call(id: 1) #=> <h1>1 was expensive</h1>
-      #   # subsequent calls with identical props are instant
+      #   Expensive.call(id: 1) #=> <h1>1</h1>
+      #   # subsequent calls with identical args are instant
+      #   Expensive.call(id: 1) #=> <h1>1</h1>, instantly!
       #
-      #   # subsequent calls with _different_ props take five seconds
-      #   Expensive.call(id: 2) #=> <h1>2 was expensive</h1>
+      #   # subsequent calls with _different_ args take five seconds
+      #   Expensive.call(id: 2) #=> <h1>2</h1>
       #
       # @return [String, Object] the cached (or computed) output of render
-      def self.call(*props, &block)
-        memoized(*props) { super }
+      def self.call(*args, &block)
+        memoized(*args) { super }
       end
 
       # Check the class-level cache, set it to &miss if nil.
       # @return [Object] the output of &miss.call
-      def self.memoized(*props, &miss)
-        cache.fetch(key(*props), &miss)
+      def self.memoized(*args, &miss)
+        cache.fetch(key(*args), &miss)
       end
 
       # @return [Integer] a cache key for this component
-      def self.key(*props)
-        props.hash
+      def self.key(*args)
+        args.hash
       end
 
       # Clear the cache of each descendant class.

data/lib/rack/component/refinements.rb

@@ -0,0 +1,14 @@
+module Rack
+  class Component
+    # These are a few refinements to the core classes to make rendering easier
+    module Refinements
+      refine Array do
+        # Join arrays with line breaks, so that calling list.map(&:render)
+        # results in usable HTML
+        def to_s
+          join("\n")
+        end
+      end
+    end
+  end
+end

data/rack-component.gemspec

@@ -34,7 +34,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'benchmark-ips', '~> 2.7'
   spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'overcommit', '~> 0'
   spec.add_development_dependency 'pry', '~> 0.11'
   spec.add_development_dependency 'rack-test', '~> 0'
   spec.add_development_dependency 'rake', '~> 10.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-component
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Chris Frank
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-19 00:00:00.000000000 Z
+date: 2018-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -38,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.16'
-- !ruby/object:Gem::Dependency
-  name: overcommit
-  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: pry
   requirement: !ruby/object:Gem::Requirement
@@ -186,7 +172,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".overcommit.yml"
 - ".reek.yml"
 - ".rspec"
 - ".rubocop.yml"
@@ -199,6 +184,7 @@ files:
 - bin/setup
 - lib/rack/component.rb
 - lib/rack/component/component_cache.rb
+- lib/rack/component/refinements.rb
 - rack-component.gemspec
 homepage: https://www.github.com/chrisfrank/rack-component
 licenses:

data/.overcommit.yml

@@ -1,37 +0,0 @@
-# Use this file to configure the Overcommit hooks you wish to use. This will
-# extend the default configuration defined in:
-# https://github.com/brigade/overcommit/blob/master/config/default.yml
-#
-# At the topmost level of this YAML file is a key representing type of hook
-# being run (e.g. pre-commit, commit-msg, etc.). Within each type you can
-# customize each hook, such as whether to only run it on certain files (via
-# `include`), whether to only display output if it fails (via `quiet`), etc.
-#
-# For a complete list of hooks, see:
-# https://github.com/brigade/overcommit/tree/master/lib/overcommit/hook
-#
-# For a complete list of options that you can use to customize hooks, see:
-# https://github.com/brigade/overcommit#configuration
-#
-# Uncomment the following lines to make the configuration take effect.
-
-PreCommit:
-  Rake:
-    enabled: true
-    command: ['bundle', 'exec', 'rake']
-
-#  RuboCop:
-#    enabled: true
-#    on_warn: fail # Treat all warnings as failures
-#
-#  TrailingWhitespace:
-#    enabled: true
-#    exclude:
-#      - '**/db/structure.sql' # Ignore trailing whitespace in generated files
-#
-#PostCheckout:
-#  ALL: # Special hook name that customizes all hooks of this type
-#    quiet: true # Change all post-checkout hooks to only display output on failure
-#
-#  IndexTags:
-#    enabled: true # Generate a tags file with `ctags` each time HEAD changes