get 0.1.0

data/lib/get/db.rb

@@ -0,0 +1,29 @@
+module Get
+  class Db
+    class << self
+      attr_accessor :entity, :query_key, :collection, :store
+
+      def entity_factory
+        @factory ||= EntityFactory.new(entity, name, collection, query_key)
+      end
+    end
+
+    def initialize(actions)
+      @actions = actions
+      @query = Get.adapter.new(self.class.store)
+    end
+
+    def call
+      execute_queries
+      self.class.entity_factory.build(@query)
+    end
+
+    private
+
+    def execute_queries
+      @actions.each do |action, options|
+        @query.send(action, options)
+      end
+    end
+  end
+end

data/lib/get/entities/collection.rb

@@ -0,0 +1,39 @@
+module Get
+  module Entities
+    class Collection
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def each
+        @collection.each do |result|
+          yield singular_entity(result)
+        end
+      end
+
+      def [](index)
+        singular_entity(@collection[index])
+      end
+
+      private
+
+      def method_missing(method)
+        if [:length, :size, :empty?, :present?].include? method
+          @collection.send(method)
+        elsif [:first, :last].include? method
+          singular_entity(@collection.send(method))
+        end
+      end
+
+      def singular_entity(record)
+        singular_entity_class.new(Get.adapter.new(record).to_hash)
+      end
+
+      # Collection classes have the form Get::Entities::TypesMapper
+      # Single output requires the form Get::Entities::TypeMapper
+      def singular_entity_class
+        @singular_entity ||= Kernel.const_get('Get').const_get('Entities').const_get(self.class.name.demodulize.singularize)
+      end
+    end
+  end
+end

data/lib/get/entities/single.rb

@@ -0,0 +1,13 @@
+require 'hashie'
+
+module Get
+  module Entities
+    class Single < Hash
+      include Hashie::Extensions::MethodAccess
+
+      def initialize(attributes)
+        update(attributes)
+      end
+    end
+  end
+end

data/lib/get/entities.rb

@@ -0,0 +1,14 @@
+module Get
+  module Entities
+    CLASS_PREFIX = 'Get'
+
+    class << self
+      def const_missing(name)
+        return super(name) unless name.to_s.match(/^#{CLASS_PREFIX}/)
+
+        parent_klass = name.to_s.plural? ? Get::Entities::Collection : Get::Entities::Single
+        Get::Entities.const_set(name, Class.new(parent_klass))
+      end
+    end
+  end
+end

data/lib/get/entity_factory.rb

@@ -0,0 +1,34 @@
+module Get
+  class EntityFactory
+    def initialize(entity, query_class_name, is_collection, result_key)
+      @entity, @query_class_name, @is_collection, @result_key = entity, query_class_name, is_collection, result_key
+    end
+
+    def build(adapter_result)
+      klass.new(db_result(adapter_result))
+    end
+
+    private
+
+    def db_result(adapter_result)
+      @is_collection ? adapter_result.context : adapter_result.to_hash
+    end
+
+    def klass
+      Get.entity_for(key) || Get::Entities.const_get(dynamic_class)
+    end
+
+    def key
+      @query_class_name.demodulize.symbolize
+    end
+
+    def dynamic_class
+      "#{::Get::Entities::CLASS_PREFIX}#{dynamic_key.camelize}"
+    end
+
+    def dynamic_key
+      return @result_key.to_s if @result_key # Special case for ancestor queries
+      @is_collection ? @entity.to_s.pluralize : @entity.to_s
+    end
+  end
+end

data/lib/get/errors.rb

@@ -0,0 +1,12 @@
+module Get
+  module Errors
+    class Base < StandardError
+    end
+
+    class MethodNotImplemented < StandardError
+    end
+
+    class InvalidAncestry < StandardError
+    end
+  end
+end

data/lib/get/run_methods.rb

@@ -0,0 +1,11 @@
+module Get
+  module RunMethods
+    def run(*context)
+      new(*context).run
+    end
+
+    def run!(*context)
+      new(*context).run!
+    end
+  end
+end

data/lib/get.rb

@@ -0,0 +1,47 @@
+require 'get/adapters/abstract_adapter'
+require 'get/adapters/active_record'
+require 'get/builders/base_builder'
+require 'get/builders/ancestry_builder'
+require 'get/builders/query_builder'
+require 'get/core_extensions/string'
+require 'get/entities/single'
+require 'get/entities/collection'
+require 'get/builders'
+require 'get/configuration'
+require 'get/db'
+require 'get/entities'
+require 'get/entity_factory'
+require 'get/errors'
+require 'get/run_methods'
+
+module Get
+  extend Get::Configuration
+
+  ASK_CLASS_REGEX = /^(.*)(By|From)(.*)/
+
+  class << self
+    attr_writer :configuration
+
+    def included(base)
+      base.class_eval do
+        extend ::Get::RunMethods
+      end
+    end
+
+    def const_missing(name)
+      return super(name) unless name.to_s.match(ASK_CLASS_REGEX)
+      Builders.generate_class(name)
+    end
+  end
+
+  def run
+    run!
+  rescue ::Get::Errors::Base
+  end
+
+  def run!
+    call
+  rescue *Get.adapter.expected_errors => e
+    raise ::Get::Errors::Base.new(e.message)
+  end
+end

data/spec/get_spec.rb

@@ -0,0 +1,326 @@
+require 'spec_helper'
+
+if !defined?(ActiveRecord::Base)
+  puts "** require 'active_record' to run the specs in #{__FILE__}"
+else
+  ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+  ActiveRecord::Migration.suppress_messages do
+    ActiveRecord::Schema.define(:version => 0) do
+      create_table(:employers, force: true) {|t| t.string :name }
+      create_table(:users, force: true) {|t| t.string :first_name; t.string :last_name; t.references :employer; }
+      create_table(:sports_cars, force: true) {|t| t.string :make; t.references :employer; }
+    end
+  end
+
+  module GetSpec
+    class Employer < ActiveRecord::Base
+      has_many :users
+      has_many :sports_cars
+    end
+
+    class User < ActiveRecord::Base
+      belongs_to :employer
+    end
+
+    class SportsCar < ActiveRecord::Base
+      belongs_to :employer
+    end
+  end
+end
+
+describe Get do
+  let(:last_name) { 'Turner' }
+  let(:adapter) { :active_record }
+
+  # Preserve system config for other tests
+  before(:all) { @system_config = Get.configuration }
+  after(:all) { Get.configuration = @system_config }
+
+  # Reset base config with each iteration
+  before { Get.configure { |config| config.adapter = adapter } }
+  after do
+    GetSpec::User.delete_all
+    GetSpec::Employer.delete_all
+    Get.reset
+  end
+
+  class MyCustomEntity < Get::Entities::Collection
+    def east_london_length
+      "#{length}, bruv"
+    end
+  end
+
+  describe '#configure' do
+    context '#register_entity' do
+      let(:user_count) { 3 }
+
+      before do
+        Get.configure { |config| config.register_entity(:users_by_last_name, MyCustomEntity) }
+        user_count.times { GetSpec::User.create(last_name: last_name) }
+      end
+      after { Get.reset }
+
+      it 'gets registers entity' do
+        expect(Get.configuration.entity_for(:users_by_last_name)).to eq MyCustomEntity
+      end
+
+      it 'returns specified entity type after querying db' do
+        result = Get::UsersByLastName.run(last_name)
+        expect(result.is_a? MyCustomEntity).to be true
+        expect(result.east_london_length).to eq "#{user_count}, bruv"
+      end
+    end
+  end
+
+  context '#entity_for' do
+    context 'when entity has been registered' do
+      before do
+        Get.configure do |config|
+          config.adapter = adapter
+          config.register_entity(:users_by_last_name, MyCustomEntity)
+        end
+      end
+      after { Get.reset }
+
+      it 'registers entity' do
+        expect(Get.entity_for(:users_by_last_name)).to eq MyCustomEntity
+      end
+    end
+
+    context 'when entity has not been registered' do
+      it 'returns nil' do
+        expect(Get.entity_for(:users_by_last_name)).to be nil
+      end
+    end
+  end
+
+  context '#adapter' do
+    context 'when the adapter is set' do
+      it 'returns the correct adapter class' do
+        expect(Get.adapter).to eq Get::Adapters::ActiveRecord
+      end
+    end
+
+    context 'when the adapter is not set' do
+      before { Get.configure { |config| config.adapter = nil } }
+      after { Get.reset }
+
+      it 'throws error' do
+        expect { Get.adapter }.to raise_error(Get::Errors::Base)
+      end
+    end
+  end
+
+  context '#reset' do
+    before do
+      Get.configure do |config|
+        config.adapter = 'my_adapter'
+        config.register_entity(:users_by_last_name, MyCustomEntity)
+      end
+      Get.reset
+    end
+    it 'resets the config' do
+      expect(Get.configuration.adapter).to be nil
+      expect(Get.entity_for(:users_by_last_name)).to be nil
+    end
+  end
+
+  context '#run!' do
+    context 'singular form' do
+      context 'when the record exists' do
+        let!(:user) { GetSpec::User.create(last_name: last_name) }
+
+        context 'field in class name' do
+          it 'gets the records based on By[KEY]' do
+            result = Get::UserById.run!(user.id)
+            expect(result.to_h).to eq user.attributes
+          end
+
+          it 'returns a dynamically generated response entity' do
+            expect(Get::UserById.run!(user.id).is_a?(Get::Entities::Single)).to be true
+          end
+        end
+
+        context 'field in parameters' do
+          it 'gets the records based on parameters' do
+            result = Get::UserBy.run!(last_name: last_name)
+            expect(result.to_h).to eq user.attributes
+          end
+
+          it 'returns a dynamically generated response entity' do
+            expect(Get::UserBy.run!(last_name: last_name).is_a?(Get::Entities::Single)).to be true
+          end
+        end
+      end
+
+      context 'when the record does not exist' do
+        it 'returns nil' do
+          expect { Get::UserById.run!(999) }.to raise_error Get::Errors::Base
+        end
+      end
+    end
+  end
+
+  context '#run' do
+    context 'singular form' do
+      context 'when the record exists' do
+        let!(:user) { GetSpec::User.create(last_name: last_name) }
+
+        context 'field in class name' do
+          it 'gets the records based on By[KEY]' do
+            result = Get::UserById.run(user.id)
+            expect(result.to_h).to eq user.attributes
+          end
+
+          it 'returns a dynamically generated response entity' do
+            expect(Get::UserById.run(user.id).is_a?(Get::Entities::Single)).to be true
+          end
+        end
+
+        context 'field in parameters' do
+          it 'gets the records based on parameters' do
+            result = Get::UserBy.run(last_name: last_name)
+            expect(result.to_h).to eq user.attributes
+          end
+
+          it 'returns a dynamically generated response entity' do
+            expect(Get::UserBy.run(last_name: last_name).is_a?(Get::Entities::Single)).to be true
+          end
+        end
+      end
+
+      context 'when the record does not exist' do
+        it 'returns nil' do
+          expect(Get::UserById.run(999)).to eq nil
+        end
+      end
+    end
+
+    context 'plural form' do
+      let(:last_name) { 'Turner' }
+      let(:match_count) { 3 }
+      let(:miss_count) { 2 }
+
+      context 'when records exist' do
+        before do
+          match_count.times { GetSpec::User.create(last_name: last_name)  }
+          miss_count.times { GetSpec::User.create }
+        end
+
+        context 'field in class name' do
+          it 'gets the records based on By[KEY]' do
+            result = Get::UsersByLastName.run(last_name)
+            expect(result.length).to eq match_count
+          end
+
+          it 'returns a dynamically generated response entity' do
+            expect(Get::UsersByLastName.run(last_name).is_a?(Get::Entities::Collection)).to be true
+          end
+        end
+
+        context 'field in parameters' do
+          it 'gets the records based on parameters' do
+            result = Get::UsersBy.run(last_name: last_name)
+            expect(result.length).to eq match_count
+          end
+
+          it 'returns a dynamically generated response entity' do
+            expect(Get::UsersBy.run(last_name: last_name).is_a?(Get::Entities::Collection)).to be true
+          end
+        end
+      end
+
+      context 'when no records exist' do
+        it 'returns empty collection' do
+          expect(Get::UsersBy.run(last_name: last_name).empty?).to be true
+        end
+      end
+    end
+
+    context 'ancestry' do
+      context 'direct relation' do
+        let(:employer) { GetSpec::Employer.create }
+        let!(:user1) { GetSpec::User.create(employer: employer) }
+        let!(:user2) { GetSpec::User.create(employer: employer) }
+
+        context 'ParentFromChild' do
+          it 'returns parent' do
+            expect(Get::EmployerFromUser.run(user1).to_h).to eq employer.attributes
+          end
+        end
+
+        context 'ChildrenFromParent' do
+          it 'returns children' do
+            result = Get::UsersFromEmployer.run(employer)
+            expect(result.first.to_h).to eq user1.attributes
+            expect(result.last.to_h).to eq user2.attributes
+          end
+        end
+
+        context 'invalid ancestry' do
+          it 'throws error' do
+            expect { Get::UserFromEmployer.run(employer) }.to raise_error Get::Errors::InvalidAncestry
+          end
+        end
+      end
+
+      context 'using via' do
+        let(:employer) { GetSpec::Employer.create }
+        let(:user) { GetSpec::User.create(employer: employer) }
+        let(:sportscar) { GetSpec::SportsCar.create(employer: employer) }
+
+        before do
+          employer.sports_cars << sportscar
+        end
+
+        it 'returns the correct ancestor' do
+          result = Get::SportsCarsFromUser.run(user, via: [:employer])
+          expect(result.first.to_h).to eq sportscar.attributes
+        end
+      end
+    end
+  end
+end
+
+describe Get::Builders::AncestryBuilder do
+  let(:name) { 'UserFromEmployer' }
+
+  before { Get.configure { |config| config.adapter = :active_record } }
+  after { Get.reset }
+
+  subject { Get::Builders::AncestryBuilder.new(name) }
+
+  describe '#class' do
+    it 'builds a class that inherits from Get::Db' do
+      expect(subject.class.superclass).to eq Get::Db
+    end
+
+    it 'correctly assigns class-level variables' do
+      [:entity, :query_key, :collection, :store, :result_key].each do |class_var|
+        expect(subject.class.respond_to? class_var).to be true
+      end
+    end
+  end
+end
+
+describe Get::Builders::QueryBuilder do
+  let(:name) { 'UserFromEmployer' }
+
+  before { Get.configure { |config| config.adapter = :active_record } }
+  after { Get.reset }
+
+  subject { Get::Builders::QueryBuilder.new(name) }
+
+  describe '#class' do
+    it 'builds a class that inherits from Get::Db' do
+      expect(subject.class.superclass).to eq Get::Db
+    end
+
+    it 'correctly assigns class-level variables' do
+      [:entity, :query_key, :collection, :store, :field].each do |class_var|
+        expect(subject.class.respond_to? class_var).to be true
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'byebug'
+require 'rspec'
+require 'active_record'
+require 'bundler/setup'
+Bundler.setup
+
+require 'get'

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: get
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Blake Turner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Encapsulate your database queries with dynamically generated classes
+email: mail@blakewilliamturner.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/get.rb
+- lib/get/adapters/abstract_adapter.rb
+- lib/get/adapters/active_record.rb
+- lib/get/builders.rb
+- lib/get/builders/ancestry_builder.rb
+- lib/get/builders/base_builder.rb
+- lib/get/builders/query_builder.rb
+- lib/get/configuration.rb
+- lib/get/core_extensions/string.rb
+- lib/get/db.rb
+- lib/get/entities.rb
+- lib/get/entities/collection.rb
+- lib/get/entities/single.rb
+- lib/get/entity_factory.rb
+- lib/get/errors.rb
+- lib/get/run_methods.rb
+- spec/get_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/BlakeTurner/get
+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: Get is a library designed to encapsulate Rails database queries and prevent
+  query pollution in the view layer.
+test_files:
+- spec/get_spec.rb
+- spec/spec_helper.rb
+has_rdoc: