atheneum 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9dee1c4b05491234603c1a15261ed81340af57c0
+  data.tar.gz: 509d97ddd98bfba60f7ee36514a17478ed7c651d
+SHA512:
+  metadata.gz: 691ec9670f1f3e9cd80e5e3979a4df8fb3b4696fe21064adaf0eda0976d88cd7974cbc960ac9ec5612993078cab14fde09eb322fea62313989fa3fab72c165fb
+  data.tar.gz: 8ddea8d1d9137b75e2fcad952721bdc587d1e12754b9765a21d132cbc18c966ed368c9df215201358d4628578b59e97d365c21c11278add919f6bbff2bc89b6e

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Peter
+
+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,170 @@
+# Atheneum
+> *noun* **place where records are stored**
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'atheneum'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install atheneum
+
+## Usage
+### Basic#
+
+You have a user record, it's always a user, that has a password. There is a `crypted_password` field on your model from the database. Atheneum can use the crypt strategy to take care of storing and retrieving the password. It will also privatise the original attribute accessors so the objects public interface is only the new attribute accessors.
+
+**NB: you must also include bcrypt in your gems for this example**
+
+```rb
+class UserRecord < Struct.new(:crypted_password)
+  include Atheneum.crypt(:password)
+end
+
+user_record = UserRecord.new
+user_record.password = 'password'
+puts user
+# => #<struct UserRecord crypted_password="$2a$10$0lScjOJwCUVdtqGrtIgww.RbvVWXGPD.oISi4DBcIgK3f3YO66aju">
+
+user_record.password == 'password'
+# => true
+
+user_record.crypted_password
+# => NoMethodError: private method `crypted_password' called for #<UserRecord:0x0000000236f9f0>
+
+
+# Without Atheneum
+class UserRecord < Struct.new(:crypted_password)
+  def password=(password)
+    self.crypted_password = BCrypt::Password.create(password).to_s
+  end
+
+  def password
+    BCrypt::Password.new(crypted_password)
+  end
+
+  private :crypted_password, :crypted_password=
+end
+```
+#### Options
+
+Storage methods accept more than one attribute. They also take an optional configuration hash
+
+- **privatise** *(default: true)* Sets whether existing accessors should privatised
+
+- **prefix** Overwrites the strategies default prefix
+
+  Strategies with no default prefix will use the strategies name eg `SomeStrategy` => `some_strategy`
+
+#### New Storage Strategy
+
+Say you wanted some strings to be reversed before adding to the database. Perhaps exceptionally mild security.
+
+Atheneum looks up strategy classes namespaced under `Atheneum::Strategy`. These need to implement a pack and unpack method as well as optionally generating the storage location
+
+```rb
+module Atheneum
+  class Strategy
+    class Reverse < Base
+
+      def pack(item)
+        item.reverse
+      end
+
+      def unpack(item)
+        item.reverse
+      end
+
+    end
+  end
+end
+
+class LocationRecord < Struct.new(:obscured_address, :obscured_name)
+  include Atheneum.reverse :address, :name, :prefix => 'obscured', :privatise => false
+end
+
+location_record = LocationRecord.new
+
+location_record.name = 'office'
+
+location_record.obscured_name
+# => "eciffo"
+```
+
+## Why?
+
+By privatising the existing attributes then the record object can remain an *immaculate record*, it appears to have only getters and setters. This is an example of how I have been using them. The example is with sequel, I have yet to try with active record but the priciple should hold.
+
+```rb
+require "sequel"
+require "atheneum"
+require "bcrypt"
+
+# connect to an in-memory database
+DB = Sequel.sqlite
+
+# create an users table
+DB.create_table :users do
+  primary_key :id
+  String :email
+  String :crypted_password
+end
+
+# create a user record
+class UserRecord < Sequel::Model(:users)
+  Atheneum.crypt :password
+end
+
+# create a user model
+class User < SimpleDelegator
+
+  def check_password(candidate_password)
+    password == candidate_password
+  end
+
+  private
+
+  def model
+    __getobj__
+  end
+
+end
+
+# In production
+user = User.new(UserRecord.new)
+user.password = 'password'
+user.check_password('password')
+# => true
+
+# In test
+TestRecord = Struct.new(:email, :password)
+user = User.new(TestRecord.new)
+user.password = 'password'
+user.check_password('password')
+# => true
+```
+
+#### Immaculate Record
+
+An immaculate record is one that acts purely as a data structure. In practise this works for all classes that can be proxied with a Struct/OpenStruct. Its value is in
+
+- Separating all buisness logic from state
+
+- fast tests
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/atheneum/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+Dir.glob('tasks/**/*.rake').each(&method(:import))

data/atheneum.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'atheneum/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "atheneum"
+  spec.version       = Atheneum::VERSION
+  spec.authors       = ["Peter"]
+  spec.email         = ["peterhsaxton@gmail.com"]
+  spec.summary       = %q{A micro gem for the immaculate inclusion of BCrypt protected data for example passwords}
+  spec.description   = %q{Simply declare attributes that require obscuring and that will make it so.
+                          Useful in exposing buisness logic in objects that use BCrypt
+                          This gem currently assumes that BCrypt is available rather than adding it as a dependency,
+                          future versions might support general strategies.
+                        }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.4.3"
+  spec.add_development_dependency "minitest-reporters", "~> 1.0.6"
+  spec.add_development_dependency "bcrypt", "~> 3.1.9"
+end

data/lib/atheneum.rb

@@ -0,0 +1,12 @@
+require "atheneum/version"
+require "atheneum/errors"
+require "atheneum/strategy"
+require "atheneum/storage"
+
+module Atheneum
+  def self.method_missing(strategy, *attributes, &block)
+    options = attributes.pop if attributes.last.class == Hash
+    options ||= {}
+    Storage.generate strategy, attributes, options
+  end
+end

data/lib/atheneum/errors.rb

@@ -0,0 +1,3 @@
+module Atheneum
+  StrategyUndefined = Class.new(StandardError)
+end

data/lib/atheneum/storage.rb

@@ -0,0 +1,44 @@
+module Atheneum
+
+  class Storage
+    def initialize(strategy)
+      @strategy = strategy
+    end
+
+    attr_reader :strategy
+
+    def for(records)
+      make_module(records, strategy)
+    end
+
+    def make_module(records, strategy)
+      Module.new do
+        records.each do |record|
+          define_method "#{record}=", ->(item){
+            self.send "#{strategy.store_for(record)}=", strategy.pack(item)
+          }
+
+          define_method record, -> (){
+            strategy.unpack(self.send("#{strategy.store_for(record)}"))
+          }
+        end
+
+        if strategy.privatise?
+          define_singleton_method :'included', ->(klass){
+            records.each do |record|
+              klass.send :private, strategy.store_for(record)
+              klass.send :private, "#{strategy.store_for(record)}="
+            end
+          }
+        end
+
+      end
+    end
+
+    def self.generate strategy_name, attributes, options
+      strategy = Strategy.find strategy_name
+      storage = new strategy.new(options)
+      storage.for attributes
+    end
+  end
+end

data/lib/atheneum/strategy.rb

@@ -0,0 +1,21 @@
+require_relative './strategy/reverse'
+require_relative './strategy/upper_case'
+require_relative './strategy/crypt'
+
+module Atheneum
+  class Strategy
+    def self.find(name)
+      nodule = constantize(name)
+      begin
+        const_get(nodule)
+      rescue NameError
+        raise StrategyUndefined.new "Strategy \"#{nodule}\" not found"
+      end
+    end
+
+    def self.constantize(string)
+      string.to_s.split('_').map(&:capitalize).join
+    end
+
+  end
+end

data/lib/atheneum/strategy/base.rb

@@ -0,0 +1,25 @@
+module Atheneum
+  class Strategy
+    class Base < Struct.new(:options)
+
+      def store_for(attribute)
+        "#{prefix}_#{attribute}"
+      end
+
+      def prefix
+        options.fetch(:prefix){
+          default_prefix
+        }
+      end
+
+      def default_prefix
+        str = self.class.name.split('::').last.split(/(?=[A-Z])/).map(&:downcase).join('_')
+        str[-1, 1] == 'e' ? str + 'd' : str + 'ed'
+      end
+
+      def privatise?
+        options.fetch(:privatise) { true }
+      end
+    end
+  end
+end

data/lib/atheneum/strategy/crypt.rb

@@ -0,0 +1,13 @@
+module Atheneum
+  class Strategy
+    class Crypt < Base
+      def pack(string)
+        BCrypt::Password.create(string).to_s
+      end
+
+      def unpack(crypted_record)
+        BCrypt::Password.new(crypted_record)
+      end
+    end
+  end
+end

data/lib/atheneum/strategy/reverse.rb

@@ -0,0 +1,15 @@
+require_relative './base'
+
+module Atheneum
+  class Strategy
+    class UpperCase < Base
+      def pack(item)
+        item.upcase
+      end
+
+      def unpack(item)
+        item.downcase
+      end
+    end
+  end
+end

data/lib/atheneum/strategy/upper_case.rb

@@ -0,0 +1,15 @@
+require_relative './base'
+
+module Atheneum
+  class Strategy
+    class Reverse < Base
+      def pack(item)
+        item.reverse
+      end
+
+      def unpack(item)
+        item.reverse
+      end
+    end
+  end
+end

data/lib/atheneum/version.rb

@@ -0,0 +1,3 @@
+module Atheneum
+  VERSION = "0.0.1"
+end

data/tasks/test.rake

@@ -0,0 +1,16 @@
+require 'rake/testtask'
+
+test_tasks = Dir['test/*/'].map { |d| File.basename(d) }
+
+test_tasks.each do |folder|
+  Rake::TestTask.new("test:#{folder}") do |test|
+    test.pattern = "test/#{folder}/**/*_test.rb"
+    test.verbose = true
+  end
+end
+
+desc "Run application test suite"
+Rake::TestTask.new("test") do |test|
+  test.pattern = "test/**/*_test.rb"
+  test.verbose = true
+end

data/test/atheneum/atheneum_test.rb

@@ -0,0 +1,112 @@
+require_relative '../test_config'
+
+class AtheneumTest < MiniTest::Test
+  def test_raises_error_for_undefined_strategy
+    err = assert_raises Atheneum::StrategyUndefined do
+      Atheneum.no_strategy
+    end
+    assert_match(/NoStrategy/, err.message)
+  end
+
+  def test_can_store_a_password_reversed
+    dummy_class = Struct.new(:reversed_password)
+    dummy_class = dummy_class.include Atheneum.reverse :password
+    store = dummy_class.new
+    store.password = 'password'
+    assert_equal 'password'.reverse, store.send(:reversed_password)
+  end
+
+  def test_can_retrieve_a_password_reversed
+    dummy_class = Struct.new(:reversed_password)
+    dummy_class = dummy_class.include Atheneum.reverse :password
+    store = dummy_class.new 'password'.reverse
+    assert_equal 'password', store.password
+  end
+
+  def test_can_store_a_other_reversed
+    dummy_class = Struct.new(:reversed_other)
+    dummy_class = dummy_class.include Atheneum.reverse :other
+    store = dummy_class.new
+    store.other = 'other'
+    assert_equal 'other'.reverse, store.send(:reversed_other)
+  end
+
+  def test_can_retrieve_a_other_reversed
+    dummy_class = Struct.new(:reversed_other)
+    dummy_class = dummy_class.include Atheneum.reverse :other
+    store = dummy_class.new 'other'.reverse
+    assert_equal 'other', store.other
+  end
+
+  def test_can_store_a_item_upper_cased
+    dummy_class = Struct.new(:upper_cased_item)
+    dummy_class = dummy_class.include Atheneum.upper_case :item
+    store = dummy_class.new
+    store.item = 'item'
+    assert_equal 'item'.upcase, store.send(:upper_cased_item)
+  end
+
+  def test_can_retrieve_a_item_upper_cased
+    dummy_class = Struct.new(:upper_cased_item)
+    dummy_class = dummy_class.include Atheneum.upper_case :item
+    store = dummy_class.new 'item'.upcase
+    assert_equal 'item', store.item
+  end
+
+  def test_can_include_multiple_strategies
+    dummy_class = Struct.new(:upper_cased_item, :reversed_other)
+    dummy_class = dummy_class.include Atheneum.upper_case :item
+    dummy_class = dummy_class.include Atheneum.reverse :other
+    store = dummy_class.new 'item'.upcase, 'password'.reverse
+    assert_equal 'item', store.item
+    assert_equal 'password', store.other
+  end
+
+  def test_method_missing_doesnt_affect_host_class
+    dummy_class = Struct.new(:reversed_password)
+    dummy_class = dummy_class.include Atheneum.reverse :password
+    assert_raises NoMethodError do
+      dummy_class.blah        
+    end
+  end
+
+  def test_privatizes_storage_methods
+    dummy_class = Struct.new(:reversed_password)
+    dummy_class = dummy_class.include Atheneum.reverse :password
+    store = dummy_class.new
+    assert_raises NoMethodError do
+      store.reversed_password
+    end
+    assert_raises NoMethodError do
+      store.reversed_password = 3
+    end
+  end
+
+  def test_privatizes_storage_methods_diff
+    dummy_class = Struct.new(:upper_cased_item)
+    dummy_class = dummy_class.include Atheneum.upper_case :item
+    store = dummy_class.new
+    assert_raises NoMethodError do
+      store.upper_cased_item
+    end
+    assert_raises NoMethodError do
+      store.upper_cased_item = 3
+    end
+  end
+
+  def test_doesnt_privatizes_storage_methods_diff_on_option
+    dummy_class = Struct.new(:upper_cased_item)
+    dummy_class = dummy_class.include Atheneum.upper_case :item, :privatise => false
+    store = dummy_class.new
+    store.upper_cased_item
+    store.upper_cased_item = 3
+  end
+
+  def test_can_overwrite_prefix
+    dummy_class = Struct.new(:random_password)
+    dummy_class = dummy_class.include Atheneum.reverse :password, :prefix => :random
+    store = dummy_class.new
+    store.password = 'password'
+    assert_equal 'password'.reverse, store.send(:random_password)
+  end
+end

data/test/strategy/crypt_test.rb

@@ -0,0 +1,28 @@
+require 'bcrypt'
+require_relative '../test_config'
+
+BCrypt::Engine.cost = 1
+
+class BcryptTest < MiniTest::Test
+  def strategy(options={})
+    @strategy = Atheneum::Strategy::Crypt.new options
+  end
+
+  def teardown
+    @strategy = nil
+  end
+
+  def test_hashes_saved_string
+    BCrypt::Password.stub :create, 'hashed' do
+      assert_equal 'hashed', strategy.pack('string')
+    end
+  end
+
+  def test_returns_saved_item
+    assert_equal strategy.unpack(BCrypt::Password.create('password').to_s), 'password'
+  end
+
+  def test_stored_attribute_prefixed_with_crypted
+    assert_equal 'crypted_password', strategy.store_for(:password)
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,6 @@
+require 'atheneum'
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+reporter_options = {color: true, slow_count: 5}
+Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new(reporter_options)]

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: atheneum
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Peter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.9
+description: "Simply declare attributes that require obscuring and that will make
+  it so.\n                          Useful in exposing buisness logic in objects that
+  use BCrypt\n                          This gem currently assumes that BCrypt is
+  available rather than adding it as a dependency,\n                          future
+  versions might support general strategies.\n                        "
+email:
+- peterhsaxton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- atheneum.gemspec
+- lib/atheneum.rb
+- lib/atheneum/errors.rb
+- lib/atheneum/storage.rb
+- lib/atheneum/strategy.rb
+- lib/atheneum/strategy/base.rb
+- lib/atheneum/strategy/crypt.rb
+- lib/atheneum/strategy/reverse.rb
+- lib/atheneum/strategy/upper_case.rb
+- lib/atheneum/version.rb
+- tasks/test.rake
+- test/atheneum/atheneum_test.rb
+- test/strategy/crypt_test.rb
+- test/test_config.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A micro gem for the immaculate inclusion of BCrypt protected data for example
+  passwords
+test_files:
+- test/atheneum/atheneum_test.rb
+- test/strategy/crypt_test.rb
+- test/test_config.rb