hashdown 0.2.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+bin/
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hashdown.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Solomon White
+
+MIT License
+
+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,95 @@
+# Hashdown
+
+Hashdown is a super lightweight rails plugin that adds hash-style lookups and
+option lists (for generating dropdowns) to ActiveRecord models.  Note: Hashdown
+has been updated to support Rails 3.  If you're looking for the original plugin
+version, it's in the [rails 2 branch](https://github.com/rubysolo/hashdown/tree/rails2)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hashdown'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hashdown
+
+## Usage
+
+Given the following class definition:
+
+    class State < ActiveRecord::Base
+      finder :abbreviation
+    end
+
+You can look up states via their abbreviations like so:
+
+    @colorado = State[:CO]
+
+By default, calling the finder method with a token that does not exist in the
+database will result in an ActiveRecord::RecordNotFount exception being thrown.
+This can be overridden by adding a :default option to your finder declaration.
+
+    class PurchaseOrder < ActiveRecord::Base
+      finder :number, :default => nil
+    end
+
+In this case, PurchaseOrder['00734'] will silently return nil if that number is
+not found.
+
+These types of reference data models are often something you need to populate a
+select list on your form, so hashdown includes a method to generate your option
+list:
+
+1. Declare your model to be selectable:
+
+    class State < ActiveRecord::Base
+      selectable
+    end
+
+2. Call select_options in your form to return a set of name, value pairs to
+pass into a select builder:
+
+    <%= form.select :state_id, State.select_options %>
+
+By default, selectable will return the :id of the record as the value, and the
+:name attribute value as the display.  This can be overridden inline in the
+select_options call:
+
+    State.select_options(:name, :abbreviation)
+
+The grouped_options_for_select format is also supported:
+
+    State.select_options(:group => :region)
+
+Adding finder and selectable to a model is roughly equivalent to the following
+implementation:
+
+    class State < ActiveRecord::Base
+      validates_uniqueness_of :abbreviation
+
+      def self.[](state_code)
+        find_by_abbreviation(state_code)
+      end
+
+      def self.select_options
+        find(:all).map{|s| [s.name, s.id] }
+      end
+    end
+
+...except hashdown adds configuration for flexibility and caching for speedy
+lookups.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+task :spec do
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = %w{--colour --format progress}
+    t.pattern = 'spec/**/*_spec.rb'
+  end
+end
+
+desc "Default: run specs."
+task :default => :spec

data/hashdown.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/hashdown/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Solomon White"]
+  gem.email         = ["rubysolo@gmail.com"]
+  gem.description   = %q{Hashdown}
+  gem.summary       = %q{super lightweight Rails plugin that adds hash-style lookups and option list (for generating dropdowns) to ActiveRecord models}
+  gem.homepage      = "https://github.com/rubysolo/hashdown"
+
+  gem.add_dependency 'activerecord', '~> 3.0'
+
+  gem.add_development_dependency 'pry-nav'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'sqlite3'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "hashdown"
+  gem.require_paths = ["lib"]
+  gem.version       = Hashdown::VERSION
+end

data/lib/hashdown/cache.rb

@@ -0,0 +1,51 @@
+module Hashdown
+  def self.cache
+    @cache ||= rails_cache || local_cache
+  end
+
+  def self.cache=(value)
+    @cache = value
+  end
+
+  def self.force_cache_miss?
+    Rails.env.test? if defined?(Rails)
+  end
+
+  def self.cache_key(source, class_name, token=nil)
+    ['hashdown', class_name, source, token].compact.join('-')
+  end
+
+  def self.uncache(source, class_name, token)
+    cache.delete(cache_key(source, class_name, token))
+  end
+
+  class Config
+    def initialize(hash={})
+      @data = hash
+    end
+
+    def method_missing(method_id, *args)
+      if method_id.to_s =~ /^(\w*)=$/
+        @data[$1.to_sym] = args.first
+      elsif method_id.to_s =~ /^(\w*)\?$/
+        @data.has_key?($1.to_sym)
+      else
+        if @data.has_key?(method_id)
+          @data[method_id]
+        else
+          super
+        end
+      end
+    end
+  end
+
+  private
+
+  def self.rails_cache
+    Rails.cache if defined?(Rails)
+  end
+
+  def self.local_cache
+    ActiveSupport::Cache::MemoryStore.new
+  end
+end

data/lib/hashdown/finder.rb

@@ -0,0 +1,45 @@
+require 'hashdown/cache'
+
+module Hashdown
+  module Finder
+    def finder(attribute, options={})
+      self.extend ClassMethods
+      self.send(:include, InstanceMethods)
+
+      hashdown.finder = Config.new(options.merge(:key => attribute))
+
+      validates attribute, :uniqueness => true
+
+      after_save :clear_hashdown_finder_cache
+      after_destroy :clear_hashdown_finder_cache
+    end
+
+    module ClassMethods
+      def hashdown
+        @hashdown ||= Config.new
+      end
+
+      def [](token)
+        Hashdown.cache.fetch(Hashdown.cache_key(:finder, self.to_s, token), :force => Hashdown.force_cache_miss?) do
+          where({hashdown.finder.key => token.to_s}).first || (
+            hashdown.finder.default? ?
+              hashdown.finder.default :
+              raise(ActiveRecord::RecordNotFound)
+          )
+        end
+      end
+    end
+
+    module InstanceMethods
+      def hashdown
+        self.class.hashdown
+      end
+
+      def clear_hashdown_finder_cache
+        Hashdown.uncache(:finder, self.class.to_s, self[hashdown.finder.key])
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend Hashdown::Finder

data/lib/hashdown/select_options.rb

@@ -0,0 +1,56 @@
+module Hashdown
+  module SelectOptions
+    def select_options(*args)
+      unless self.respond_to?(:map_records_to_select_options)
+        self.extend ClassMethods
+        self.send(:include, InstanceMethods)
+
+        after_save    :clear_select_options_cache
+        after_destroy :clear_select_options_cache
+      end
+
+      options = args.pop if args.last.is_a?(Hash)
+      options ||= {}
+
+      options[:label] ||= args.shift || :name
+      options[:value] ||= args.shift || :id
+
+      scope = scoped
+      scope = scope.order(options[:label]) if scope.arel.orders.empty? && columns.any?{|c| c.name == options[:label].to_s }
+
+      Hashdown.cache.fetch(Hashdown.cache_key(:select_options, self.to_s, select_options_cache_key(options, scope)), :force => Hashdown.force_cache_miss?) do
+        if grouping = options[:group]
+          scope.all.group_by {|record| grouping.call(record) }.map do |group, records|
+            [group, map_records_to_select_options(records, options)]
+          end
+        else
+          map_records_to_select_options(scope.all, options)
+        end
+      end
+    end
+
+    module ClassMethods
+      private
+
+      def select_options_cache_key(options, scope)
+        key = options.sort.each_with_object(""){|ck,(k,v)| ck << "#{ k }:#{ v };" }
+        key << scope.to_sql
+        key = Digest::MD5.hexdigest(key)
+      end
+
+      def map_records_to_select_options(records, options)
+        records.map{|record| [ record[options[:label]], record[options[:value]] ] }
+      end
+    end
+
+    module InstanceMethods
+      private
+
+      def clear_select_options_cache
+        Hashdown.cache.delete_matched(Regexp.new(Hashdown.cache_key(:select_options, self.class.to_s)))
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend Hashdown::SelectOptions

data/lib/hashdown/version.rb

@@ -0,0 +1,3 @@
+module Hashdown
+  VERSION = "0.2.0"
+end

data/lib/hashdown.rb

@@ -0,0 +1,3 @@
+require "hashdown/version"
+require "hashdown/finder"
+require "hashdown/select_options"

data/spec/lib/hashdown/cache_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Hashdown do
+  describe 'cache' do
+    describe 'in a Rails project' do
+      before { Object.const_set('Rails', mock(cache: :rails_cache)) }
+      after  { Object.send(:remove_const, 'Rails') }
+
+      it 'delegates to Rails.cache if available' do
+        Hashdown.cache.should eq Rails.cache
+      end
+    end
+
+    it 'creates a new cache store if Rails.cache unavailable' do
+      Hashdown.cache.class.should eq ActiveSupport::Cache::MemoryStore
+    end
+  end
+end

data/spec/lib/hashdown/finder_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Hashdown::Finder do
+  describe 'bracket lookup' do
+    it 'is added to enabled models' do
+      State.should respond_to(:[])
+    end
+
+    it 'finds a record by a string key value' do
+      State['CA'].name.should eq 'California'
+    end
+
+    it 'finds a record by a symbol key value' do
+      State[:CO].name.should eq 'Colorado'
+    end
+
+    it 'adds uniqueness validation to key attribute' do
+      State.where(abbreviation: 'CO').count.should eq 1
+      State.new(abbreviation: 'CO').should_not be_valid
+    end
+  end
+
+  describe 'missing/invalid key' do
+    it 'raises record not found exception' do
+      lambda { State[:HI] }.should raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    it 'allows setting a default to avoid exception' do
+      lambda { StateDefaultNil[:HI].should be_nil }.should_not raise_error
+    end
+  end
+
+  describe 'cache layer' do
+    let(:florida) { State.new(abbreviation: 'FL', name: 'Florida') }
+
+    it 'caches found records' do
+      scope = mock(first: florida)
+      State.should_receive(:where).once.and_return(scope)
+
+      2.times { State[:FL].name.should eq 'Florida' }
+    end
+
+    describe 'in test environment' do
+      before { Object.const_set('Rails', mock(env: mock(test?: true), cache: ActiveSupport::Cache::MemoryStore.new)) }
+      after  { Object.send(:remove_const, 'Rails') }
+
+      it 'forces cache miss' do
+        scope = mock(first: florida)
+        State.should_receive(:where).twice.and_return(scope)
+
+        2.times { State[:FL].name.should eq 'Florida' }
+      end
+    end
+
+    it 'clears the cache on save' do
+      scope = mock(first: florida)
+      State.should_receive(:where).twice.and_return(scope)
+
+      State[:FL].save
+      State[:FL]
+    end
+
+    it 'clears the cache on destroy' do
+      scope = mock(first: florida)
+      State.should_receive(:where).twice.and_return(scope)
+
+      State[:FL].destroy
+      State[:FL]
+    end
+  end
+end

data/spec/lib/hashdown/select_options_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Hashdown::SelectOptions do
+  let(:state_names) { %w(Arizona California Colorado New\ York Texas) }
+
+  it 'adds #select_options to ActiveRecord classes' do
+    State.should respond_to(:select_options)
+  end
+
+  it 'returns one entry per database record' do
+    State.select_options.length.should eq State.count
+  end
+
+  it 'sorts by label if no order is specified' do
+    State.select_options.map(&:first).should eq state_names
+  end
+
+  it 'respects order if specified' do
+    Currency.select_options.map(&:first).should eq ['Renminbi', 'Euro', 'Pound Sterling', 'US Dollar']
+  end
+
+  it 'returns a list of records formatted for the #select form helper' do
+    option = State.select_options.first
+    option.first.should eq 'Arizona'
+    option.last.should eq State[:AZ].id
+  end
+
+  it 'generates grouped options' do
+    grouped_states = State.select_options(group: lambda{|state| state.name.first })
+    grouped_states.map(&:first).should eq %w( A C N T )
+    grouped_states.detect{|group, states| group == 'C' }.last.length.should eq 2
+  end
+
+  it 'supports alternate option labels' do
+    Currency.select_options(:code).map(&:first).should eq %w( CNY EUR GBP USD )
+  end
+
+  it 'supports alternate option values' do
+    Currency.select_options(:name, :code).map(&:last).should eq %w( CNY EUR GBP USD )
+  end
+
+  describe 'cache layer' do
+    let(:states) { State.all }
+    let(:mock_scope) { mock(arel: mock(orders: %w( name )), to_sql: "SELECT * FROM states") }
+
+    it 'should cache found records' do
+      mock_scope.should_receive(:all).once.and_return(states)
+      State.stub(:scoped).and_return(mock_scope)
+
+      2.times { State.select_options.length.should eq states.length }
+    end
+
+    describe 'in test environment' do
+      before { Object.const_set('Rails', mock(env: mock(test?: true), cache: ActiveSupport::Cache::MemoryStore.new)) }
+      after  { Object.send(:remove_const, 'Rails') }
+
+      it 'forces cache miss' do
+        mock_scope.should_receive(:all).twice.and_return(states)
+        State.stub(:scoped).and_return(mock_scope)
+
+        2.times { State.select_options.length.should eq states.length }
+      end
+    end
+
+    it 'respects scopes' do
+      State.select_options.map(&:first).should eq state_names
+      State.starting_with_c.select_options.map(&:first).should eq %w( California Colorado )
+    end
+
+    it 'clears the cache on save' do
+      mock_scope.should_receive(:all).twice.and_return(states)
+      State.stub(:scoped).and_return(mock_scope)
+
+      State.select_options
+      states.first.save
+      State.select_options
+    end
+
+    it 'clears the cache on destroy' do
+      mock_scope.should_receive(:all).twice.and_return(states)
+      State.stub(:scoped).and_return(mock_scope)
+
+      State.select_options
+      states.first.destroy
+      State.select_options
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'pry-nav'
+require 'rspec'
+require 'rspec/autorun'
+
+require 'sqlite3'
+require 'active_record'
+require 'hashdown/finder'
+require 'hashdown/select_options'
+
+ActiveRecord::Base.establish_connection(:adapter  => 'sqlite3', :database => ':memory:')
+load 'support/models.rb'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.before(:each) do
+    ActiveRecord::Base.establish_connection(:adapter  => 'sqlite3', :database => ':memory:')
+    load 'support/schema.rb'
+    load 'support/seeds.rb'
+
+    Hashdown.cache = nil
+  end
+
+  config.after(:each) do
+    Hashdown.cache = nil
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,19 @@
+class State < ActiveRecord::Base
+  scope :starting_with_c, where("name like 'C%'")
+  finder :abbreviation
+end
+
+class SortedState < ActiveRecord::Base
+  self.table_name = 'states'
+  default_scope order(:abbreviation)
+  finder :abbreviation
+end
+
+class StateDefaultNil < ActiveRecord::Base
+  self.table_name = 'states'
+  finder :abbreviation, default: nil
+end
+
+class Currency < ActiveRecord::Base
+  default_scope order(:code)
+end

data/spec/support/schema.rb

@@ -0,0 +1,11 @@
+ActiveRecord::Schema.verbose = false
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :states do |t|
+    t.string :name, :abbreviation
+  end
+
+  create_table :currencies do |t|
+    t.string :name, :code
+  end
+end

data/spec/support/seeds.rb

@@ -0,0 +1,42 @@
+class ActiveRecord::Base
+  def self.seed(data_table)
+    data_table = data_table.strip.split(/\s*\n\s*/)
+    data_table.reject!{|row| row =~ /---/ }
+
+    headers = data_table.shift.split(/\s*\|\s*/)[1..-1]
+
+    delete_all
+
+    data_table.each do |row|
+      data = Hash[*headers.zip(row.split(/\s*\|\s*/)[1..-1]).flatten].with_indifferent_access
+      if data[primary_key]
+        connection.execute("INSERT INTO #{table_name} SET #{ data.map{|k,v| "#{ connection.quote_column_name(k) } = #{ connection.quote(v) }" }.join(', ') }")
+      else
+        create(data)
+      end
+    end
+  end
+end
+
+State.seed %q{
+  +--------------+------------+
+  | abbreviation | name       |
+  +--------------+------------+
+  | AZ           | Arizona    |
+  | NY           | New York   |
+  | CA           | California |
+  | TX           | Texas      |
+  | CO           | Colorado   |
+  +--------------+------------+
+}
+
+Currency.seed %q{
+  +------+----------------+
+  | code | name           |
+  +------+----------------+
+  | GBP  | Pound Sterling |
+  | EUR  | Euro           |
+  | USD  | US Dollar      |
+  | CNY  | Renminbi       |
+  +------+----------------+
+}

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: hashdown
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Solomon White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70301816154100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70301816154100
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: &70301816153640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70301816153640
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70301816152900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70301816152900
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70301815747100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70301815747100
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70301815746680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70301815746680
+description: Hashdown
+email:
+- rubysolo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hashdown.gemspec
+- lib/hashdown.rb
+- lib/hashdown/cache.rb
+- lib/hashdown/finder.rb
+- lib/hashdown/select_options.rb
+- lib/hashdown/version.rb
+- spec/lib/hashdown/cache_spec.rb
+- spec/lib/hashdown/finder_spec.rb
+- spec/lib/hashdown/select_options_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+- spec/support/seeds.rb
+homepage: https://github.com/rubysolo/hashdown
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1096798538704753083
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1096798538704753083
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: super lightweight Rails plugin that adds hash-style lookups and option list
+  (for generating dropdowns) to ActiveRecord models
+test_files:
+- spec/lib/hashdown/cache_spec.rb
+- spec/lib/hashdown/finder_spec.rb
+- spec/lib/hashdown/select_options_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+- spec/support/seeds.rb