errol 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c43849e71e1ed66ec52d37a22663f6b4d44332e9
+  data.tar.gz: 41200a851e4a32ba4e67a52f7887a4550ed94348
+SHA512:
+  metadata.gz: 9ce82562e4c6f32be9824a1547630942750e818a3de7010ed4af9bc9e1cb9e96f1345d64570e047d3d85b239c102075b5b5d1ea85a1e802d9f6789f541937ad7
+  data.tar.gz: 051da105e5b3623b20fd0902cc6ae68a35eee31dda201c4265f6f54241052a8acc7f5974b10654f0c23e7ba6bcf3795d38317824f0f0c6c83bf9145aaf75820a

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 errol.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Peter Saxton
+
+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,220 @@
+# Errol
+
+**Repository build on top of [sequel](http://sequel.jeremyevans.net/) to store simple data records.** Errol encourages a separation of concerns in the domain model of a system where data is persisted. It uses these extra components to include a default solution for paginating its records.
+
+They key components are the *Repository* that is responsible for storing and retrieving *Records* in response to various *Inquiries*. Records are not the same as the bloated god objects of active record but should remain simple data stores. The responsibility of a record is representing a database row with domain friendly types, this means serialising data. Where the behaviour that is no longer represented on your model now belongs is dependant on the system. It is often worth having an object that wraps the data record to define extra behaviour as well as methods to save. Errol ships with an entity that can be used as a starting point for these objects.  
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'errol'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install errol
+
+## Usage
+
+Usage is best described by each of the components
+
+### Inquiry
+The inquiry object is simply a store of data that was sent with each inquiry plus an optional set of defaults. The repository assumes that a page and page_size is available when using the ability to paginate
+
+```rb
+class Posts
+  class Inquiry < Errol::Inquiry
+    default :order, :id
+    default :page, 1
+    default :page_size, 12
+    default :published, true
+  end
+end
+
+inquiry = Inquiry.new :page => 2
+inquiry.page
+# => 2
+inquiry.published?
+# => true
+inquiry.other
+# => raise DefaultValueUndefined
+```
+
+### Records
+These are simply sequel models. there is no wrapper and you define them as sequel models
+
+```rb
+class Post
+  class Record < Sequel::Model(:posts)
+  end
+end
+```
+
+### Repository
+The repository contains all the records, instances of a repository contain a subset dependant on the inquiry, by default the inquiry will be used to paginate.
+
+```rb
+class Posts < Errol::Repository
+
+  class << self
+    # The repository needs to know what records it is storing
+    def record_class
+      Post::Record
+    end
+
+    # The repository needs to know how to build a requirments hash that may be empty into a inquiry containing defaults
+    def inquiry(requirements)
+      Posts::Inquiry.new(requirements)
+    end
+  end
+
+  # This the odd part, the dataset method is called when returning data. This a custom method that allows arbitrarily complex manipulation of data using settings from the inquiry
+  def dataset
+    partial = raw_dataset
+    partial = partial.order(inquiry.order)
+    partial = partial.where(:published) if inquiry.published
+    partial
+  end
+end
+
+page = Posts.new
+# First page of published posts ordered by id
+
+page.first_page?
+# => true
+
+page.page_size
+# => 12
+
+page.each { |post| puts post }
+# Outputs each of the posts on the page
+
+# class methods also use an inquiry to filter data
+
+Posts.each { |post| puts post }
+# Outputs each published post in the dataset ordered by id
+
+Posts.each(:published => false, :order => :created_at) { |post| puts post }
+# Outputs each post in the database ordered by creation date
+
+#if you want a filtered dataset which is not paginated pass false as the last argument
+set = Posts.new({:order => :created_at}, false)
+```
+
+### Entity
+Entities are an optional wrapper around the record objects. My personal criteria as to if can add something to my record is can this object still be represented by an open struct? This allows me to test my entities with Ostructs and see the data thats is pulled or pushed to them. Use a entity for anything else. Say we want a post intro which is the first 20 words of a post. *I often name my entities after the domain object and name space the record below them, this is because I never interact with the data record.*
+
+```rb
+# Without Errol::Entity
+class Post
+  def initialize(record)
+    @record = record
+  end
+
+  attr_reader :record
+
+  def intro
+    body.split[' '][0, 3].join(' ') + '...'
+  end
+
+  def body
+    record.body
+  end
+
+  def title
+    record.title
+  end
+
+  def save
+    Posts.save record
+  end
+end
+
+# With Errol::Entity
+class Customer < Errorl::Entity
+  repository = Customers
+  entry_accessor :title, :body
+
+  def intro
+    body.split[' '][0, 3].join(' ') + '...'
+  end
+end
+```
+
+If you are working with entities you might not want to have to keep wrapping records. The repository allows you to define a method for sending out and accepting entities.
+
+```rb
+class Posts < Errol::Repository
+  class << self
+    def dispatch(record)
+      Post.new(record)
+    end
+
+    def receive(entity)
+      entity.record
+    end
+  end
+end
+```
+
+## Documentation
+
+### Entity
+
+**::entry_reader** `entity.entry_reader(*entries) => self`
+
+defines reader access to entries on the record which is short hand for calling `entity.record.entry`
+
+**::entry_writer** `entity.entry_writer(*entries) => self`
+
+defines writer access to entries on the record which is short hand for calling `entity.record.entry = value`
+
+**::boolean_query** `entity.boolean_query(*entries) => self`
+
+defines query(appends '?' on method name) to entries on the record which is short hand for calling `!!entity.record.entry`
+
+**::entry_accessor** `entity.entry_accessor(*entries) => self`
+
+short hand for entry_reader and entry_writer for entries
+
+**::boolean_accessor** `entity.boolean_accessor(*entries) => self`
+
+short hand for boolean_query and entry_writer for entries
+
+**#set** `entity.set(**attributes) => self`
+
+sends each item in the hash to a method matching the key with argument of the value
+
+**#save** `entity.save => self`
+
+Submits itself to the declared repository for saving
+
+**#destroy** `entity.destroy => self`
+
+Submits itself to the declared repository for removal
+
+**#refresh** `entity.refresh => self`
+
+Submits itself to the declared repository to be refreshed
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/errol/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
+
+## Upcoming
+1. separate repository save method to insert and replace
+2. method missing bang methods call normal method then save
+3. raise error if entity initialised with nil?
+4. Protect record access method. Problem is access is require by repository to run sql filtering

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+
+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/errol.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'errol/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "errol"
+  spec.version       = Errol::VERSION
+  spec.authors       = ["Peter Saxton"]
+  spec.email         = ["peterhsaxton@gmail.com"]
+  spec.summary       = %q{Repository to store and deliver encapsulated records.}
+  spec.description   = %q{Based of the Sequel Library to deliver a repository interface to persisted data. Handles pagination by default}
+  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_dependency "sequel", "~> 4.19"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "minitest-reporters", "~> 1.0"
+end

data/lib/errol.rb

@@ -0,0 +1,8 @@
+require "errol/version"
+require "errol/repository"
+require "errol/inquiry"
+require "errol/entity"
+
+module Errol
+  # Your code goes here...
+end

data/lib/errol/entity.rb

@@ -0,0 +1,109 @@
+module Errol
+  class Entity
+    RepositoryUndefined = Class.new(StandardError)
+    NilRecord = Class.new(StandardError)
+    def self.repository=(repository)
+      @repository = repository
+    end
+
+    def self.repository
+      @repository || (raise RepositoryUndefined, "No repository set for #{self.name}")
+    end
+
+    def self.entry_reader(*entries)
+      entries.each do |entry|
+        define_method entry do
+          record.public_send entry
+        end
+      end
+    end
+
+    def self.entry_writer(*entries)
+      entries.each do |entry|
+        define_method "#{entry}=" do |value|
+          record.public_send "#{entry}=", value
+        end
+      end
+    end
+
+    def self.boolean_query(*entries)
+      entries.each do |entry|
+        define_method "#{entry}?" do
+          !!(record.public_send entry)
+        end
+      end
+    end
+
+    def self.entry_accessor(*entries)
+      entry_reader *entries
+      entry_writer *entries
+    end
+
+    def self.boolean_accessor(*entries)
+      boolean_query *entries
+      entry_writer *entries
+    end
+
+    def initialize(record)
+      # raise NilRecord, "Tried to initialise #{self.class.name} with nil record" if record.nil?
+      @record = record
+    end
+
+    attr_reader :record
+    # protected :record
+    entry_reader :id
+
+    def set(**attributes)
+      attributes.each do |attribute, value|
+        self.public_send "#{attribute}=", value
+      end
+      self
+    end
+
+    def set!(*args)
+      set(*args)
+      save
+    end
+
+    def repository
+      self.class.repository
+    end
+
+    def save
+      repository.save self
+      self
+    end
+
+    def destroy
+      repository.remove self
+      self
+    end
+
+    def refresh
+      repository.refresh self
+      self
+    end
+
+    def ==(other)
+      other.class == self.class && other.record == record
+    end
+    alias_method :eql?, :==
+    # def method_missing(method_name, *args, &block)
+    #   if method_name.to_s =~ /^(.+)!$/
+    #     self.public_send($1, *args, &block)
+    #     repository.save self
+    #   else
+    #     super
+    #   end
+    # end
+
+    # def respond_to?(method_name)
+    #   if method_name.to_s =~ /^(.+)!$/
+    #     self.respond_to? $1
+    #   else
+    #     super
+    #   end
+    # end
+
+  end
+end

data/lib/errol/inquiry.rb

@@ -0,0 +1,33 @@
+module Errol
+  class Inquiry
+    DefaultValueUndefined = Class.new(StandardError)
+
+    def initialize(options={})
+      options.each do |key, value|
+        defaults[key.to_sym] = value
+      end
+    end
+
+    def defaults
+      @defaults ||= self.class.defaults.clone
+    end
+
+    def self.default(property, value)
+      defaults[property.to_sym] = value
+    end
+
+    def self.defaults
+      @defaults ||= {}
+    end
+
+    def method_missing(method_name, *args, &block)
+      if method_name.to_s =~ /^(.+)(?:\?)$/
+        !!self.public_send($1, *args, &block)
+      else
+        defaults.fetch(method_name) do |requirement|
+          raise DefaultValueUndefined.new "Inquiry requirement for \"#{requirement}\" has not been set"
+        end
+      end
+    end
+  end
+end