rack-component 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 441fd93e02f16449c7284aa7c84b72d01bc8b87e133999c2ed4b7a637431be07
-  data.tar.gz: ab7f5669c4b28c991f173180597f7b94c64de8cc8158d31da18f60b3927010f8
+  metadata.gz: 98202bd82c61277b38d1300b503c561372f617ef49ff5f61a7ec6582830d1d25
+  data.tar.gz: ddb88dacbe4bd2c60a3ba337b08ded9d6b9151e01300c2226ef428bd5ab83aa1
 SHA512:
-  metadata.gz: 3232586822a9c38192cdbab6aa537236a331334ec0fe5ccaefbcdb8a62be92617f9fa94c4f372dbefc6eed92d0a8ef34e4c91971c6ef8b5f211bfede3d52b470
-  data.tar.gz: dbe6b3663319d39bf6ebf5c5610979a5de5713ec992dfe6dc5f5f680bd7c551ed540036addf317fdd08c93756259a4deda97a49b224dbe8ec3b28fe593574c88
+  metadata.gz: 2185f7fad25bfaed06bcfc199d4986b71739c97ec3ce54d7336299c5eff49b6d5f8b050a6096ca7a761505c4c4d2a25bb5aeb04d9e320cc7df36fc8d974aad32
+  data.tar.gz: 892055b99db3a063ab79128fe4ef5e89de7d93055d8f006d5ad5197fde8c6aad48fff87db65078b93bc4a113e6aa9357683fda92dcae9a2776607859fc9998ee

data/.reek.yml

@@ -3,6 +3,9 @@ detectors:
     enabled: false
   UncommunicativeVariableName:
     enabled: false
+  NestedIterators:
+    ignore_iterators:
+      - each_object
 exclude_paths:
   - bin
   - client

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rack-component (0.3.0)
+    rack-component (0.4.0)
 
 GEM
   remote: https://rubygems.org/
@@ -33,7 +33,7 @@ GEM
     pry (0.11.3)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
-    rack (2.0.5)
+    rack (2.0.6)
     rack-protection (2.0.4)
       rack
     rack-test (0.8.3)
@@ -89,6 +89,7 @@ DEPENDENCIES
   benchmark-ips (~> 2.7)
   bundler (~> 1.16)
   pry (~> 0.11)
+  rack (~> 2.0.6)
   rack-component!
   rack-test (~> 0)
   rake (~> 10.0)

data/README.md

@@ -3,125 +3,249 @@
 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.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
 ```ruby
-gem 'rack-component', require: 'rack/component'
+bundle add 'rack-component'
 ```
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
+## Get Started
 
-    $ gem install rack-component
+The simplest component is just a function:
 
-## API Reference
-
-Please see the
-[YARD docs on rubydoc.info](https://www.rubydoc.info/gems/rack-component)
+```ruby
+Greeter = lambda do |env|
+  "<h1>Hi, #{env[:name]}.</h1>"
+end
 
-## Usage
+Greeter.call(name: 'Mina') #=> '<h1>Hi, Mina.</h1>'
+```
 
-Subclass `Rack::Component` and `#call` it:
+Convert your function to a `Rack::Component` when it needs instance methods or state:
 
 ```ruby
 require 'rack/component'
-class Useless < Rack::Component
+
+class FormalGreeter < Rack::Component
+  render do |env|
+    "<h1>Hi, #{title} #{env[:name]}.</h1>"
+  end
+
+  def title
+    # the hash you pass to `call` is available as `env` in instance methods
+    env[:title] || "President"
+  end
 end
 
-Useless.call #=> the output Useless.new.render
+FormalGreeter.call(name: 'Macron') #=> "<h1>Hi, President Macron.</h1>"
+FormalGreeter.call(name: 'Merkel', title: 'Chancellor') #=> "<h1>Hi, Chancellor Merkel.</h1>"
 ```
 
-The default implementation of `#render` is to yield the component instance to
-whatever block you pass to `Component.call`, like this:
+Replace `#call` with `#memoized` to make re-renders instant:
 
 ```ruby
-Useless.call { |instance| "Hello from #{instance}" }
-#=> "Hello from #<Useless:0x00007fcaba87d138>"
+require 'rack/component'
+require 'net/http'
+class NetworkGreeter < Rack::Component
+  render do |env|
+    "Hi, #{get_job_title_from_api} #{env[:name]}."
+  end
 
-Useless.call do |instance|
-  Useless.call do |second_instance|
-    <<~HTML
-      <h1>Hello from #{instance}</h1>
-      <p>And also from #{second_instance}"</p>
-    HTML
+  def get_job_title_from_api
+    endpoint = URI("http://api.heads-of-state.gov/")
+    Net::HTTP.get("#{endpoint}?q=#{env[:name]}")
   end
 end
-# =>
-# <h1>Hello from #<Useless:0x00007fcaba87d138></h1>
-# <p>And also from #<Useless:0x00007f8482802498></p>
+
+NetworkGreeter.memoized(name: 'Macron')
+# ...after a slow network call to our fictional Heads Of State API
+#=> "Hi, President Macron."
+
+NetworkGreeter.memoized(name: 'Macron') # subsequent calls with the same env are instant.
+#=> "Hi, President Macron."
+
+NetworkGreeter.memoized(name: 'Merkel')
+# ...this env is new, so NetworkGreeter makes another network call
+#=> "Hi, Chancellor Merkel."
+
+NetworkGreeter.memoized(name: 'Merkel') #=> instant! "Hi, Chancellor Merkel."
+NetworkGreeter.memoized(name: 'Macron') #=> instant! "Hi, President Macron."
 ```
 
-### Implement `#render` or add instance methods to make Components do work
+## Recipes
+
+### Render one component inside another
+You can nest Rack::Components as if they were [React Children][JSX Children] by
+calling them with a block.
 
-Peruse the [specs][specs] for examples of component chains that handle
-data fetching, views, and error handling in Sinatra and raw Rack.
+```ruby
+Layout.call(title: 'Home') { Content.call }
+```
 
-Here's a component chain that prints headlines from Daring Fireball’s JSON feed:
+Here's a more fully fleshed example:
 
 ```ruby
 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
+# let's say this is a Sinatra app:
+get '/posts/:id' do
+  PostPage.call(id: params[:id])
+end
 
-  def render
-    yield @response
+# fetch a post from the database and render it inside a layout
+class PostPage < Rack::Component
+  render do |env|
+    post = Post.find(id: env[:id])
+    # Nest a PostContent instance inside a Layout instance
+    Layout.call(title: post.title) do
+      PostContent.call(title: post.title, body: post.body)
+    end
   end
 end
 
-# Parse items from a JSON Feed document
-class JSONFeedParser < Rack::Component
-  require 'json'
-  def initialize(data)
-    @items = JSON.parse(data).fetch('items')
+class PostContent < Rack::Component
+  render do |env|
+    <<~HTML
+      <article>
+        <h1>#{env[:title]}</h1>
+        #{env[:body]}
+      </article>
+    HTML
   end
+end
 
-  def render
-    yield @items
+class Layout < Rack::Component
+  render do |env, &children|
+    # the `&children` param is just a standard ruby block
+    <<~HTML
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>#{env[:title]}</title>
+        </head>
+        <body>
+          #{children.call}
+        </body>
+      </html>
+    HTML
   end
 end
+```
 
-# Render an HTML list of posts
-class PostsList < Rack::Component
-  def initialize(posts:, style: '')
-    @posts = posts
-    @style = style
-  end
+### Render an HTML list from an array
+[JSX Lists][JSX Lists] use JavaScript's `map` function. Rack::Component does
+likewise.
 
-  def render
+```ruby
+require 'rack/component'
+class PostsList < Rack::Component
+  render do |env|
     <<~HTML
-      <ul style="#{@style}">
-        #{@posts.map(&ListItem).join}"
+      <h1>This is a list of posts</h1>
+      <ul>
+        #{render_items}
       </ul>
     HTML
   end
 
-  ListItem = ->(post) { "<li>#{post['title']}</li>" }
+  def render_items
+    env[:posts].map { |post|
+      <<~HTML
+        <li class="item">
+          <a href="#{post[:url]}>
+            #{post[:name]}
+          </a>
+        </li>
+      HTML
+    }.join #unlike, with JSX, you need to call `join` on your array
+  end
 end
 
-# 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')
+posts = [{ name: 'First Post', id: 1 }, { name: 'Second', id: 2 }]
+PostsList.call(posts: posts) #=> <h1>This is a list of posts</h1> <ul>...etc
+```
+
+### Mount a Rack::Component tree inside a Rails app
+For when just a few parts of your app are built with components:
+
+```ruby
+# config/routes.rb
+mount MyComponent, at: '/a_path_of_your_choosing'
+
+# config/initializers/my_component.rb
+require 'rack/component'
+class MyComponent < Rack::Component
+  render do |env|
+    <<~HTML
+      <h1>Hello from inside a Rails app!</h1>
+    HTML
   end
 end
-end
-#=> A <ul> full of headlines from Daring Fireball
+```
 
+### Build an entire Rack app out of Rack::Components
+In real life, maybe don't do this. Use [Roda] or [Sinatra] for routing, and use
+Rack::Component instead of Controllers, Views, and templates. But to see an
+entire app built only out of Rack::Components, see
+[the example spec](https://github.com/chrisfrank/rack-component/blob/master/spec/raw_rack_example_spec.rb).
+
+
+## API Reference
+The full API reference is available here:
+
+https://www.rubydoc.info/gems/rack-component
+
+For info on how to clear or change the size of the memoziation cache, please see
+[the spec][spec].
+
+## Performance
+On my machine, Rendering a Rack::Component is almost 10x faster than rendering a
+comparable Tilt template, and almost 100x faster than ERB from the Ruby standard
+library. Run `ruby spec/benchmarks.rb` to see what to expect in your env.
+
+```
+$ ruby spec/benchmarks.rb
+Warming up --------------------------------------
+     Ruby stdlib ERB     2.807k i/100ms
+       Tilt (cached)    28.611k i/100ms
+              Lambda   249.958k i/100ms
+           Component   161.176k i/100ms
+Component [memoized]    94.586k i/100ms
+Calculating -------------------------------------
+     Ruby stdlib ERB     29.296k (± 2.0%) i/s -    148.771k in   5.080274s
+       Tilt (cached)    319.935k (± 2.8%) i/s -      1.602M in   5.012009s
+              Lambda      6.261M (± 1.2%) i/s -     31.495M in   5.031302s
+           Component      2.773M (± 1.8%) i/s -     14.022M in   5.057528s
+Component [memoized]      1.276M (± 0.9%) i/s -      6.432M in   5.041348s
 ```
 
+Notice that using `Component#memoized` is *slower* than using `Component#call`
+in this benchmark. Because these components do almost nothing, it's more work to
+check the memoziation cache than to just render. For components that don't
+access a database, don't do network I/O, and aren't very CPU-intensive, it's
+probably fastest not to memoize. For components that do I/O, using `#memoize`
+can speed things up by several orders of magnitude.
+
+## Compatibility
+Rack::Component has zero dependencies, and will work in any Rack app. It should
+even work *outside* a Rack app, because it's not actually dependent on Rack. I
+packaged it under the Rack namespace because it follows the Rack `call`
+specification, and because that's where I use and test it.
+
+## Anybody using this in production?
+
+Aye:
+
+- [future.com](https://www.future.com/)
+- [Seattle & King County Homelessness Response System](https://hrs.kc.future.com/)
+
+## Ruby reference:
+
+Where React uses [JSX] to make components more ergonomic, Rack::Component leans
+heavily on some features built into the Ruby language, specifically:
+
+- [Heredocs]
+- [String Interpolation]
+- [Calling methods with a block][Ruby Blocks]
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run
@@ -143,4 +267,12 @@ https://github.com/chrisfrank/rack-component.
 
 MIT
 
-[specs]: https://github.com/chrisfrank/rack-component/tree/master/spec
+[spec]: https://github.com/chrisfrank/rack-component/blob/master/spec/rack/component_spec.rb
+[JSX]: https://reactjs.org/docs/introducing-jsx.html
+[JSX Children]: https://reactjs.org/docs/composition-vs-inheritance.html
+[JSX Lists]: https://reactjs.org/docs/lists-and-keys.html
+[Heredocs]: https://ruby-doc.org/core-2.5.0/doc/syntax/literals_rdoc.html#label-Here+Documents
+[String Interpolation]: http://ruby-for-beginners.rubymonstas.org/bonus/string_interpolation.html
+[Ruby Blocks]: https://mixandgo.com/learn/mastering-ruby-blocks-in-less-than-5-minutes
+[Roda]: http://roda.jeremyevans.net
+[Sinatra]: http://sinatrarb.com

data/Rakefile

@@ -4,15 +4,20 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
 task :cop do
-  system 'bundle exec rubocop lib'
+  sh 'bundle exec rubocop lib'
 end
 
 task :reek do
-  system 'bundle exec reek lib'
+  sh 'bundle exec reek lib'
 end
 
 task :doc do
-  system 'bundle exec yard doc'
+  sh 'bundle exec yard doc'
+end
+
+task :commit do
+  sh 'bundle exec rake'
+  sh 'git add -A && git commit --verbose'
 end
 
 task default: %i[cop reek spec doc]

data/bin/setup

@@ -4,6 +4,5 @@ IFS=$'\n\t'
 set -vx
 
 bundle install
-bundle exec overcommit
 
 # Do any other automated setup that you need to do here

data/lib/rack/component.rb

@@ -1,108 +1,121 @@
-require_relative 'component/component_cache'
-require_relative 'component/refinements'
+require_relative 'component/version'
+require_relative 'component/memory_cache'
 
 module Rack
-  # Subclass Rack::Component to compose declarative, component-based responses
-  # to HTTP requests
+  # Subclass Rack::Component to compose functional, declarative responses to
+  # HTTP requests.
   class Component
-    VERSION = '0.3.0'.freeze
-
-    # Initialize a new component with the given args and render it.
-    #
-    # @example Render a HelloWorld component
-    #   class HelloWorld < Rack::Component
-    #     def initialize(name)
-    #       @name = name
-    #     end
-    #
-    #     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(*args, &block)
-      new(*args).render(&block)
-    end
-
-    # 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(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 arguments.
-    class Memoized < self
-      CACHE_SIZE = 100 # limit to 100 keys by default to prevent leaking RAM
-
-      # 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))
-      end
-
-      # @example render a Memoized Component
-      #   class Expensive < Rack::Component::Memoized
-      #     def initialize(id)
-      #       @id = id
-      #     end
-      #
-      #     def work
-      #       sleep 5
-      #       "#{@id}"
+    class << self
+      # Instantiate a new component with given +env+ return its rendered output.
+      # @example Render a child block inside an HTML document
+      #   class Layout < Rack::Component
+      #     render do |env, &child|
+      #       <<~HTML
+      #         <!DOCTYPE html>
+      #         <html>
+      #           <head>
+      #             <title>#{env[:title]}</title>
+      #           </head>
+      #           <body>#{child.call}</body>
+      #         </html>
+      #       HTML
       #     end
+      #   end
       #
-      #     def render
-      #       %(<h1>#{work}</h1>)
+      #   Layout.call(title: 'Hello') { "<h1>Hello from Rack::Component" } #=>
+      #   # <!DOCTYPE html>
+      #   # <html>
+      #   #   <head>
+      #   #     <title>Hello</title>
+      #   #   </head>
+      #   #   <body><h1>Hello from Rack::Component</h1></body>
+      #   # </html>
+      def call(env = {}, &child)
+        new(env).call env, &child
+      end
+
+      # Use +memoized+ instead of +call+ to memoize the result of +call(env)+
+      # and return it. Subsequent uses of +memoized(env)+ with the same +env+
+      # will be read from a threadsafe in-memory cache, not computed.
+      # @example Cache a slow network call
+      #   class Fetcher < Rack::Component
+      #     render do |env|
+      #       Net::HTTP.get(env[:uri]).to_json
       #     end
       #   end
       #
-      #   # first call takes five seconds
-      #   Expensive.call(id: 1) #=> <h1>1</h1>
-      #   # subsequent calls with identical args are instant
-      #   Expensive.call(id: 1) #=> <h1>1</h1>, instantly!
+      #   Fetcher.memoized(uri: '/slow/api.json')
+      #   # ...
+      #   # many seconds later...
+      #   # => { some: "data" }
       #
-      #   # 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(*args, &block)
-        memoized(*args) { super }
+      #   Fetcher.memoized(uri: '/slow/api.json') #=> instant! { some: "data" }
+      #   Fetcher.memoized(uri: '/other/source.json') #=> slow again!
+      def memoized(env = {}, &child)
+        cache.fetch(env.hash) { call(env, &child) }
       end
 
-      # Check the class-level cache, set it to &miss if nil.
-      # @return [Object] the output of &miss.call
-      def self.memoized(*args, &miss)
-        cache.fetch(key(*args), &miss)
+      # Forget all memoized calls to this component.
+      def flush
+        cache.flush
       end
 
-      # @return [Integer] a cache key for this component
-      def self.key(*args)
-        args.hash
+      # Use a +render+ block define what a component will do when you +call+ it.
+      # @example Say hello
+      #   class Greeter < Rack::Component
+      #     render do |env|
+      #       "Hi, #{env[:name]}"
+      #     end
+      #   end
+      #
+      #   Greeter.call(name: 'Jim') #=> 'Hi, Jim'
+      #   Greeter.call(name: 'Bones') #=> 'Hi, Bones'
+      def render(&block)
+        define_method :call, &block
       end
 
-      # Clear the cache of each descendant class.
-      # Generally you'll call this on Rack::Component::Memoized directly.
-      # @example Clear all caches:
-      #   Rack::Component::Memoized.clear_caches
-      def self.clear_caches
-        ObjectSpace.each_object(singleton_class) do |descendant|
-          descendant.cache.flush
-        end
+      # Find or initialize a cache store for a Component class.
+      # With no configuration, the store is a threadsafe in-memory cache, capped
+      # at 100 keys in length to avoid leaking RAM.
+      # @example Use a larger cache instead
+      #   class BigComponent < Rack::Component
+      #     cache { MemoryCache.new(length: 2000) }
+      #   end
+      def cache
+        @cache ||= (block_given? ? yield : MemoryCache.new(length: 100))
       end
     end
+
+    def initialize(env = {})
+      @env = env
+    end
+
+    # Out of the box, a +Rack::Component+ just returns whatever +env+ you call
+    # it with, or yields with +env+ if you call it with a block.
+    # Use a class-level +render+ block when wiriting your Components to override
+    # this method with more useful behavior.
+    # @see Rack::Component#render
+    #
+    # @example a useless component
+    #   Useless = Class.new(Rack::Component)
+    #   Useless.call(number: 1) #=> { number: 1 }
+    #   Useless.call(number: 2) #=> { number: 2 }
+    #   Useless.call(number: 2) { |env| "the number was #{env[:number]" }
+    #   #=> 'the number was 2'
+    #
+    # @example a useful component
+    #   class Greeter < Rack::Component
+    #     render do |env|
+    #       "Hi, #{env[:name]}"
+    #     end
+    #   end
+    #
+    #   Greeter.call(name: 'Jim') #=> 'Hi, Jim'
+    #   Greeter.call(name: 'Bones') #=> 'Hi, Bones'
+    def call(*)
+      block_given? ? yield(env) : env
+    end
+
+    attr_reader :env
   end
 end

data/lib/rack/component/memory_cache.rb

@@ -0,0 +1,41 @@
+module Rack
+  class Component
+    # A threadsafe, in-memory, per-component cache
+    class MemoryCache
+      attr_reader :store, :mutex
+
+      # Use a hash to store cached calls and a mutex to make it threadsafe
+      def initialize(length: 100)
+        @store = {}
+        @length = length
+        @mutex = Mutex.new
+      end
+
+      # Fetch a key from the cache, if it exists
+      # If the key doesn't exist and a block is passed, set the key
+      # @return the cached value
+      def fetch(key)
+        store.fetch(key) do
+          set(key, yield) if block_given?
+        end
+      end
+
+      # Empty the cache
+      # @return [Hash] the empty store
+      def flush
+        mutex.synchronize { @store = {} }
+      end
+
+      private
+
+      # Cache a value and return it
+      def set(key, value)
+        mutex.synchronize do
+          store[key] = value
+          store.delete(@store.keys.first) if store.length > @length
+          value
+        end
+      end
+    end
+  end
+end

data/lib/rack/component/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class Component
+    VERSION = '0.4.0'.freeze
+  end
+end

data/rack-component.gemspec

@@ -1,6 +1,6 @@
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rack/component'
+require 'rack/component/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'rack-component'
@@ -35,12 +35,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'benchmark-ips', '~> 2.7'
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'pry', '~> 0.11'
+  spec.add_development_dependency 'rack', '~> 2.0.6'
   spec.add_development_dependency 'rack-test', '~> 0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'reek', '~> 5'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.59'
-  spec.add_development_dependency 'sinatra', '~> 2'
   spec.add_development_dependency 'tilt', '~> 2'
   spec.add_development_dependency 'yard', '~> 0.9'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-component
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Chris Frank
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-21 00:00:00.000000000 Z
+date: 2018-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.6
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
@@ -122,20 +136,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.59'
-- !ruby/object:Gem::Dependency
-  name: sinatra
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
@@ -183,8 +183,8 @@ files:
 - bin/console
 - bin/setup
 - lib/rack/component.rb
-- lib/rack/component/component_cache.rb
-- lib/rack/component/refinements.rb
+- lib/rack/component/memory_cache.rb
+- lib/rack/component/version.rb
 - rack-component.gemspec
 homepage: https://www.github.com/chrisfrank/rack-component
 licenses:

data/lib/rack/component/component_cache.rb

@@ -1,45 +0,0 @@
-module Rack
-  class Component
-    # Threadsafe in-memory cache
-    class ComponentCache
-      attr_reader :store
-
-      # Initialize a mutex for threadsafe reads and writes
-      LOCK = Mutex.new
-
-      # Store cache in a hash
-      def initialize(limit = 100)
-        @store = {}
-        @limit = limit
-      end
-
-      # Fetch a key from the cache, if it exists
-      # If the key doesn't exist and a block is passed, set the key
-      # @return the cached value
-      def fetch(key)
-        store.fetch(key) do
-          write(key, yield) if block_given?
-        end
-      end
-
-      # empty the cache
-      # @return [Hash] the empty store
-      def flush
-        LOCK.synchronize { @store = {} }
-      end
-
-      private
-
-      # Cache a value and return it
-      def write(key, value)
-        LOCK.synchronize do
-          store[key] = value
-          store.delete(@store.keys.first) if store.length > @limit
-          value
-        end
-      end
-    end
-
-    private_constant :ComponentCache
-  end
-end

data/lib/rack/component/refinements.rb

@@ -1,14 +0,0 @@
-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