hstore_accessor_rails5 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f720dcc6711d9da0adc6cee02b9ecc2d289cc11c
+  data.tar.gz: 57c21b5df60bfbc5e55ac2b26756c4b0aee3adc9
+SHA512:
+  metadata.gz: da7bf66134be0f819dd15ea4295eb0c2704b7daa9f910ba551bd93144c232986a8c2b4ff3d8f8cd4c1412867e59b78837d638c777462bdb149d47b2d3a1902b3
+  data.tar.gz: 5a4509cf56aef71989825d11503fc6d808ac25c5243b66b2b786b58d9fb21402dbfc59be2bec9f69589c3638969d51c4321df655623d3737ae71645e3eb3c195

data/.gitignore

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

data/.rubocop.yml

@@ -0,0 +1,43 @@
+AllCops:
+  Include:
+    - Rakefile
+Lint/SpaceBeforeFirstArg:
+  Enabled: false
+Lint/UnusedBlockArgument:
+  Enabled: false
+Lint/UnusedMethodArgument:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/LineLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
+Style/AlignParameters:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+Style/ClassVars:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Style/FileName:
+  Enabled: false
+Style/GuardClause:
+  Enabled: false
+Style/IndentHash:
+  Enabled: false
+Style/RescueModifier:
+  Enabled: false
+Style/SignalException:
+  Enabled: false
+Style/SpaceAroundEqualsInParameterDefault:
+  Enabled: false
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/Appraisals

@@ -0,0 +1,11 @@
+appraise "activerecord-4.2" do
+  gem "activerecord", "4.2.0"
+end
+
+appraise "activerecord-4.1" do
+  gem "activerecord", "4.1.0"
+end
+
+appraise "activerecord-4.0" do
+  gem "activerecord", "4.0.0"
+end

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :test do
+  gem "pg", ">= 0.14.1"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 JC Grubbs
+
+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,291 @@
+# HstoreAccessor
+
+Based on (hanselmw's work adding support for rails 5)(https://github.com/hanselmw/hstore_accessor/tree/)add-support-for-rails-5
+Hstore Accessor allows you to treat fields on an hstore column as though they were actual columns being picked up by ActiveRecord. This is especially handy when trying to avoid sparse columns while making use of [single table inheritence](#single-table-inheritance). Hstore Accessor currently supports ActiveRecord versions 4.0, 4.1, and 4.2.
+
+Not a fan of hstore? Why not check out [Jsonb Accessor](https://github.com/devmynd/jsonb_accessor)?
+
+## Table of Contents
+
+* [Installation](#installation)
+* [Setup](#setup)
+* [ActiveRecord methods generated for fields](#activerecord-methods-generated-for-fields)
+* [Scopes](#scopes)
+  * [String Fields](#string-fields)
+  * [Integer, Float, and Decimal Fields](#integer-float-decimal-fields)
+  * [Datetime Fields](#datetime-fields)
+  * [Date Fields](#date-fields)
+  * [Array Fields](#array-fields)
+  * [Boolean Fields](#boolean-fields)
+* [Single Table Inheritence](#single-table-inheritance)
+* [Upgrading](#upgrading)
+* [Contributing](#contributing)
+  - [Basics](#basics)
+  - [Developing Locally](#developing-locally)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "hstore_accessor"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hstore_accessor
+
+## Setup
+
+The `hstore_accessor` method accepts the name of the hstore column you'd
+like to use and a hash with keys representing fields and values
+indicating the type to be stored in that field.  The available types
+are: `string`, `integer`, `float`, `decimal`, `datetime`, `date`, `boolean`, `array`, and `hash`. It is available on any class that inherits from `ActiveRecord::Base`.
+
+```ruby
+class Product < ActiveRecord::Base
+  hstore_accessor :options,
+    color: :string,
+    weight: :integer,
+    price: :float,
+    built_at: :datetime,
+    build_date: :date,
+    tags: :array, # deprecated
+    ratings: :hash # deprecated
+    miles: :decimal
+end
+```
+
+Now you can interact with the fields stored in the hstore directly.
+
+```ruby
+product = Product.new
+product.color = "green"
+product.weight = 34
+product.price = 99.95
+product.built_at = Time.now - 10.days
+product.build_date = Date.today
+product.popular = true
+product.tags = %w(housewares kitchen) # deprecated
+product.ratings = { user_a: 3, user_b: 4 } # deprecated
+product.miles = 3.14
+```
+
+Reading these fields works as well.
+
+```ruby
+product.color # => "green"
+product.price  # => 99.95
+```
+
+In order to reduce the storage overhead of hstore keys (especially when
+indexed) you can specify an alternate key.
+
+```ruby
+hstore_accessor :options,
+  color: { data_type: :string, store_key: "c" },
+  weight: { data_type: :integer, store_key: "w" }
+```
+
+In the above example you can continue to interact with the fields using
+their full name but when saved to the database the field will be set
+using the `store_key`.
+
+Additionally, dirty tracking is implemented in the same way that normal
+`ActiveRecord` fields work.
+
+```ruby
+product.color          #=> "green"
+product.color = "blue"
+product.changed?       #=> true
+product.color_changed? #=> true
+product.color_was      #=> "green"
+product.color_change  #=> ["green", "blue"]
+```
+
+## ActiveRecord methods generated for fields
+
+```ruby
+class Product < ActiveRecord::Base
+  hstore_accessor :data, field: :string
+end
+```
+
+* `field`
+* `field=`
+* `field?`
+* `field_changed?`
+* `field_was`
+* `field_change`
+* `reset_field!`
+* `restore_field!`
+* `field_will_change!`
+
+Overriding methods is supported, with access to the original Hstore Accessor implementation available via `super`.
+
+Additionally, there is also `hstore_metadata_for_<fields>` on both the class and instances. `column_for_attribute` will also return a column object for an Hstore Accessor defined field. If you're using ActiveRecord 4.2, `type_for_attribute` will return a type object for Hstore Accessor defined fields the same as it does for actual columns.
+
+## Scopes
+
+The `hstore_accessor` macro also creates scopes for `string`, `integer`,
+`float`, `decimal`, `time`, `date`, `boolean`, and `array` fields.
+
+### String Fields
+
+For `string` types, a `with_<key>` scope is created which checks for
+equality.
+
+```ruby
+Product.with_color("green")
+```
+
+### Integer, Float, Decimal Fields
+
+For `integer`, `float` and `decimal` types five scopes are created:
+
+```ruby
+Product.price_lt(240.00)  # price less than
+Product.price_lte(240.00) # price less than or equal to
+Product.price_eq(240.00)  # price equal to
+Product.price_gte(240.00) # price greater than or equal to
+Product.price_gt(240.00)  # price greater than
+```
+
+### Datetime Fields
+
+For `datetime` fields, three scopes are created:
+
+```ruby
+Product.built_at_before(Time.now)         # built before the given time
+Product.built_at_eq(Time.now - 10.days)   # built at an exact time
+Product.built_at_after(Time.now - 4.days) # built after the given time
+```
+
+### Date Fields
+
+For `date` fields, three scopes are created:
+
+```ruby
+Product.build_date_before(Date.today)         # built before the given date
+Product.build_date_eq(Date.today - 10.days)   # built at an exact date
+Product.built_date_after(Date.today - 4.days) # built after the given date
+```
+
+### Array Fields
+
+*Note: the array field type is deprecated. It is available in version 0.9.0 but not > 1.0.0*
+
+For `array` types, two scopes are created:
+
+```ruby
+Product.tags_eq(%w(housewares kitchen))       # tags equaling
+Product.tags_contains("kitchen")              # tags containing a single value
+Product.tags_contains(%w(housewares kitchen)) # tags containing a number of values
+```
+
+### Boolean Fields
+
+Two scopes are created for `boolean` fields:
+
+```ruby
+Product.is_popular  # => when popular is set to true
+Product.not_popular # => when popular is set to false
+```
+
+Predicate methods are also available on instances:
+
+```ruby
+product = Product.new(popular: true)
+product.popular? # => true
+```
+
+### Single-table Inheritance
+
+One of the big issues with `ActiveRecord` single-table inheritance (STI)
+is sparse columns.  Essentially, as sub-types of the original table
+diverge further from their parent more columns are left empty in a given
+table.  Postgres' `hstore` type provides part of the solution in that
+the values in an `hstore` column does not impose a structure - different
+rows can have different values.
+
+We set up our table with an hstore field:
+
+```ruby
+# db/migration/<timestamp>_create_vehicles_table.rb
+class CreateVehiclesTable < ActiveRecord::Migration
+  def change
+    create_table :vehicles do |t|
+      t.string :make
+      t.string :model
+      t.integer :model_year
+      t.string :type
+      t.hstore :data
+    end
+  end
+end
+```
+
+And for our models:
+
+```ruby
+# app/models/vehicle.rb
+class Vehicle < ActiveRecord::Base
+end
+
+# app/models/vehicles/automobile.rb
+class Automobile < Vehicle
+  hstore_accessor :data,
+    axle_count: :integer,
+    weight: :float,
+    engine_details: :hash
+end
+
+# app/models/vehicles/airplane.rb
+class Airplane < Vehicle
+  hstore_accessor :data,
+    engine_type: :string,
+    safety_rating: :integer,
+    features: :hash
+end
+```
+
+From here any attributes specific to any sub-class can be stored in the
+`hstore` column avoiding sparse data.  Indices can also be created on
+individual fields in an `hstore` column.
+
+This approach was originally concieved by Joe Hirn in [this blog
+post](http://www.devmynd.com/blog/2013-3-single-table-inheritance-hstore-lovely-combination).
+
+## Upgrading
+Upgrading from version 0.6.0 to 0.9.0 should be fairly painless. If you were previously using a `time` type fields, simply change it to `datetime` like so:
+
+```ruby
+# Before...
+hstore_accessor :data, published_at: :time
+# After...
+hstore_accessor :data, published_at: :datetime
+```
+
+While the `array` and `hash` types are available in version 0.9.0, they are deprecated and are not available in 1.0.0.
+
+## Contributing
+### Basics
+1. [Fork it](https://github.com/devmynd/hstore_accessor/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write code _and_ tests
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+
+### Developing Locally
+Before you make your pull requests, please make sure you style is in line with our Rubocop settings and that all of the tests pass.
+
+1. `bundle install`
+2. `appraisal install`
+3. Make sure Postgres is installed and running
+4. `appraisal rspec` to run all the tests
+5. `rubocop` to check for style

data/Rakefile

@@ -0,0 +1,10 @@
+require "rubygems"
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new
+RuboCop::RakeTask.new
+
+task(default: [:rubocop, :spec])

data/gemfiles/activerecord_4.0.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "4.0.0"
+
+group :test do
+  gem "pg", ">= 0.14.1"
+end
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.1.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "4.1.0"
+
+group :test do
+  gem "pg", ">= 0.14.1"
+end
+
+gemspec :path => "../"