rack-si 0.0.2 → 0.1.0

data/Gemfile

@@ -2,4 +2,4 @@ source :rubygems
 
 gemspec :path => '.'
 
-gem 'herbalist', :path => '~/herbalist'
+gem 'herbalist', :path => '~/herbalist' #:git => 'git://github.com/dkastner/herbalist.git', :branch => 'basic'

data/README.markdown

@@ -0,0 +1,26 @@
+# Rack::SI
+
+Convert parameters into SI (metric) base units.
+
+We all know the metric system is far superior to the imperial/customary system (except when performing mental math on lengths and volumes) so now there is a Rack middleware that will normalize all of your measurement input into SI!
+
+# Installation
+
+    $ gem install rack-si
+
+
+    # config.ru
+    require 'rack/si'
+    
+    use Rack::SI, options
+    run MyApp
+
+# Configuration
+
+Rack::SI accepts several configuration options:
+
+* *env*: If true, the converted params will appear in the env['si.params'] hash. If set to a string, the converted params will appear in the env[custom\_string] hash.
+* *basic*: If true, and dkastner-herbalist is installed, keep Herbalist from matching spelled-out numbers and fractions. This helps performance.
+* *path*: A single path or array of paths defined as strings and/or regexes. If set, params are translated only for specified paths.
+* *whitelist*: A list of params that should be converted. All others are ignored. If left blank, all params are converted (unless blacklisted).
+* *blacklist*: A list of params that should *not* be converted. All others are converted (if whitelisted). If left blank, all params are converted.

data/lib/rack/si.rb

@@ -1,33 +1,109 @@
 require 'herbalist'
-Herbalist.basic = true
 
 module Rack
 
   # A Rack middleware for converting params to base SI units
   #
-  class Rack::SI
+  class SI
+    attr_accessor :app, :options
+
+    # These are the base SI units to which measurement params will be converted
     BASE_UNITS = [:metre, :metres, :meter, :meters, :litre, :litres, :liter, :liters, :joule, :joules, :gram, :grams, :watt, :watts]
 
-    def initialize(app)
-      @app = app
+    DEFAULT_OPTIONS = {
+      :env => false,
+      :basic => false,
+      :whitelist => [],
+      :blacklist => [],
+      :path => []
+    }
+
+    # use Rack::SI my_options
+    def initialize(app, options = {})
+      self.app = app
+      self.options = DEFAULT_OPTIONS.merge(options)
+
+      normalize_options
+      Herbalist.basic = true if Herbalist.respond_to?(:basic) && options[:basic]
+    end
+
+    # Make sure options are in the right format
+    def normalize_options
+      self.options[:whitelist] = self.options[:whitelist].map(&:to_s)
+      self.options[:blacklist] = self.options[:blacklist].map(&:to_s)
+      self.options[:path] = [self.options[:path]] unless self.options[:path].is_a?(Array)
+    end
+
+    # Called on each request
+    def call(env, options = {})
+      req = Request.new(env)
+      convert_params(env, req) if path_matches?(req)
+      app.call(env)
+    end
+
+    def path_matches?(req)
+      options[:path].empty? || options[:path].find do |path|
+        (path.is_a?(String) && req.path == path) ||
+          (path.is_a?(Regexp) && req.path =~ path)
+      end
     end
 
-    def call(env)
-      convert_params(env)
-      @app.call(env)
+    def convert_params(env, req)
+      if options[:env]
+        convert_params_in_hash(env, req)
+      else
+        convert_params_in_situ(env, req)
+      end
     end
 
-    def convert_params(env)
-      params = ::Rack::Request.new(env).params
-      env['si.params'] = params.inject({}) do |hsh, (name, value)|
-        if measurement = Herbalist.parse(value)
-          value = normalize(measurement)
+    # Convert parameters, but put them in a special hash and
+    # leave the regular Rack ENV params alone.
+    # You can specify the name of the env[] key that stores
+    # the params by configuring the app with the :env option
+    def convert_params_in_hash(env, req)
+      params = req.params
+      hash_name = options[:env].is_a?(String) ? options[:env] : 'si.params'
+      env[hash_name] = params.inject({}) do |hsh, (name, value)|
+        herbalize(hsh, name, value)
+      end
+    end
+
+    # Convert parameters "in place" - that is, modify all the 
+    # params in env so that every other middleware sees 
+    # the changes
+    def convert_params_in_situ(env, req)
+      env['si.original_params'] = req.params.dup
+      [:GET, :POST].each do |method|
+        hsh = req.send(method)
+        hsh.each do |name, value|
+          herbalize(hsh, name, value)
         end
-        hsh[name] = value
-        hsh
       end
     end
 
+    # Convert a parameter with Herbalist
+    def herbalize(hsh, name, value)
+      if herbalizable?(name) && measurement = Herbalist.parse(value)
+        hsh[name] = normalize(measurement)
+      end
+      hsh
+    end
+
+    # Decides if a param should be converted with Herbalist
+    def herbalizable?(param)
+      whitelisted?(param) && !blacklisted?(param)
+    end
+
+    def whitelisted?(param)
+      options[:whitelist].empty? || options[:whitelist].include?(param)
+    end
+
+    def blacklisted?(param)
+      !options[:blacklist].empty? && options[:blacklist].include?(param)
+    end
+
+    # Convert a param to a base unit using Alchemist's 
+    # conversion table
     def normalize(measurement)
       group_name = Alchemist.conversion_table.keys.find do |k|
         Alchemist.conversion_table[k].include?(measurement.unit_name)

data/lib/rack/si/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class SI
-    VERSION = '0.0.2'
+    VERSION = '0.1.0'
   end
 end

data/spec/si_spec.rb

@@ -5,50 +5,216 @@ describe Rack::SI do
   include Rack::Test::Methods
 
   def app
-    Rack::SI.new lambda { |env| [200, {}, []] }
+    Rack::SI.new lambda { |env| [200, {}, []] }, options
   end
 
   describe '#call' do
-    it 'returns control to the app' do
-      get '/foo'
-      last_response.should be_ok
+    context 'with default options' do
+      let(:options) { {} }
+
+      it 'returns control to the app' do
+        get '/foo'
+        last_response.should be_ok
+      end
+
+      it 'ignores missing parameters' do
+        post '/bar'
+        last_request.params.should == {}
+      end
+
+      it 'does not convert non-unit params' do
+        post '/automobile_trips', {
+          'destination' => '2,3',
+          'distance' => 233
+        }
+        last_request.params.should ==({
+          'destination' => '2,3',
+          'distance' => '233'
+        })
+      end
+
+      it 'converts any unit-ed params to base SI units' do
+        post '/automobile_trips', {
+          'destination' => '2,3',
+          'distance' => '233 miles'
+        }
+        last_request.params['destination'].should == '2,3'
+        last_request.params['distance'].to_f.should == 374977.152
+      end
+
+      it 'keeps the original params close by' do
+        post '/automobile_trips', {
+          'destination' => '2,3',
+          'distance' => '233 miles'
+        }
+        last_request.env['si.original_params']['destination'].should == '2,3'
+        last_request.env['si.original_params']['distance'].should == '233 miles'
+      end
+
+      it 'converts compound measurements' do
+        pending
+        #post '/automobile_trips', {
+          #'fuel_efficiency' => '54 miles per gallon'
+        #}
+        #last_request.env['si.params']['fuel_efficiency'].to_f.should == 86904.576
+      end
+
+      it 'converts dates' do
+        pending
+      end
     end
 
-    it 'ignores missing parameters' do
-      post '/bar'
-      last_request.env['si.params'].should == {}
+    context 'with env option' do
+      let(:options) { { :env => true } }
+
+      it 'saves SI params to a separate ENV hash if desired' do
+        post '/automobile_trips', {
+          'destination' => '2,3',
+          'distance' => '233 miles'
+        }
+        last_request.params.should == {
+          'destination' => '2,3',
+          'distance' => '233 miles'
+        }
+        last_request.env['si.params']['destination'].should be_nil
+        last_request.env['si.params']['distance'].to_f.should == 374977.152
+      end
     end
 
-    it 'does not convert non-unit params' do
-      post '/automobile_trips', {
-        'destination' => '2,3',
-        'distance' => 233
-      }
-      last_request.env['si.params'].should ==({
-        'destination' => '2,3',
-        'distance' => '233'
-      })
+    context 'with custom env option' do
+      let(:options) { { :env => 'my.hash' } }
+
+      it 'saves SI params to a custom ENV hash if desired' do
+        post '/automobile_trips', {
+          'destination' => '2,3',
+          'distance' => '233 miles'
+        }
+        last_request.params.should == {
+          'destination' => '2,3',
+          'distance' => '233 miles'
+        }
+        last_request.env['my.hash']['destination'].should be_nil
+        last_request.env['my.hash']['distance'].to_f.should == 374977.152
+      end
     end
 
-    it 'converts any unit-ed params to base SI units' do
-      post '/automobile_trips', {
-        'destination' => '2,3',
-        'distance' => '233 miles'
-      }
-      last_request.env['si.params']['destination'].should == '2,3'
-      last_request.env['si.params']['distance'].to_f.should == 374977.152
+    context 'with whitelist' do
+      let(:options) { { :whitelist => %w{distance} } }
+
+      it 'converts only whitelisted SI params' do
+        post '/automobile_trips', {
+          'destination' => '2,3',
+          'distance' => '233 miles',
+          'weight' => '2013 lbs'
+        }
+        last_request.params.should == {
+          'destination' => '2,3',
+          'distance' => '374977.152',
+          'weight' => '2013 lbs'
+        }
+      end
     end
 
-    #it 'converts compound measurements' do
-      #post '/automobile_trips', {
-        #'fuel_efficiency' => '54 miles per gallon'
-      #}
-      #last_request.env['si.params']['fuel_efficiency'].to_f.should == 86904.576
-    #end
+    context 'with blacklist' do
+      let(:options) { { :blacklist => %w{distance} } }
+
+      it 'does not convert blacklisted SI params' do
+        post '/automobile_trips', {
+          'destination' => '2,3',
+          'distance' => '233 miles',
+          'weight' => '2013 lbs'
+        }
+        last_request.params.should == {
+          'destination' => '2,3',
+          'distance' => '233 miles',
+          'weight' => '913081.4408100001'
+        }
+      end
+    end
 
-    #it 'converts dates' do
+    context 'with path option' do
+      let(:options) { { :path => ['/accepted', /also_accepted/] } }
 
-    #end
+      it 'converts params for a path matching a string' do
+        post '/accepted', {
+          'distance' => '233 miles'
+        }
+        last_request.params.should == {
+          'distance' => '374977.152'
+        }
+      end
+      it 'converts params for a path matching a regex' do
+        post '/also_accepted', {
+          'distance' => '233 miles'
+        }
+        last_request.params.should == {
+          'distance' => '374977.152'
+        }
+      end
+      it 'skips params conversion for a non-matching path' do
+        post '/fogettaboutit', {
+          'distance' => '233 miles'
+        }
+        last_request.params.should == {
+          'distance' => '233 miles'
+        }
+      end
+    end
+  end
+
+  describe '#herbalizable?' do
+    let(:options) { {} }
+    let(:si) { app }
+
+    it 'returns true if param is whitelisted and not blacklisted' do
+      si.stub!(:whitelisted?).and_return true
+      si.stub!(:blacklisted?).and_return false
+      si.herbalizable?('foo').should be_true
+    end
+    it 'returns false if param is not whitelisted' do
+      si.stub!(:whitelisted?).and_return false
+      si.herbalizable?('foo').should be_false
+    end
+    it 'returns false if param is blacklisted' do
+      si.stub!(:whitelisted?).and_return true
+      si.stub!(:blacklisted?).and_return true
+      si.herbalizable?('foo').should be_false
+    end
+  end
+
+  describe '#whitelisted?' do
+    let(:options) { {} }
+    let(:si) { app }
+
+    it 'returns true if the whitelist is empty' do
+      si.options[:whitelist] = []
+      si.whitelisted?('foo').should be_true
+    end
+    it 'returns true if the param is in the whitelist' do
+      si.options[:whitelist] = ['foo']
+      si.whitelisted?('foo').should be_true
+    end
+    it 'returns false if the param is not in the whitelist' do
+      si.options[:whitelist] = ['foo']
+      si.whitelisted?('bar').should be_false
+    end
   end
-end
 
+  describe '#blacklisted?' do
+    let(:options) { {} }
+    let(:si) { app }
+
+    it 'returns false if the blacklist is empty' do
+      si.options[:blacklist] = []
+      si.blacklisted?('foo').should be_false
+    end
+    it 'returns true if the param is in the blacklist' do
+      si.options[:blacklist] = ['foo']
+      si.blacklisted?('foo').should be_true
+    end
+    it 'returns false if the param is not in the blacklist' do
+      si.options[:blacklist] = ['foo']
+      si.blacklisted?('bar').should be_false
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-si
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-30 00:00:00.000000000Z
+date: 2012-05-01 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: herbalist
-  requirement: &2158550580 !ruby/object:Gem::Requirement
+  requirement: &2165760380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2158550580
+  version_requirements: *2165760380
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &2166031240 !ruby/object:Gem::Requirement
+  requirement: &2165759960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2166031240
+  version_requirements: *2165759960
 - !ruby/object:Gem::Dependency
   name: rack-test
-  requirement: &2166030820 !ruby/object:Gem::Requirement
+  requirement: &2165759540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2166030820
+  version_requirements: *2165759540
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2166030400 !ruby/object:Gem::Requirement
+  requirement: &2163226240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2166030400
+  version_requirements: *2163226240
 description: Choose params that are converted with Herbalist to base SI units (meters,
   grams, etc)
 email: