meek 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c750b14616a96016a9c9a1b3a657f8ef45187fa
+  data.tar.gz: df954f83e9a2da3fa618f16f8cc46e7e3a0a06d3
+SHA512:
+  metadata.gz: 34365cb8d616720e157305f4661f44c62333c9b500512a2c3ca1f13c710e94a878c26505ce06cfaa8debc9815f677e3643415d732a5a5351fe6ed199e5eab342
+  data.tar.gz: 3d9f2b0b45325fb39b78b7a2510ccbdd7ea0c6f84aaa101f7cfb4e5ea72872fe51bee2a2228f5259a6d7bc1ac51ace6b40008518bb735e14e6952c14ae622934

data/README.md

@@ -0,0 +1,36 @@
+# SilverSpoon
+In this world there are the has, and the has nots.  ActiveRecord can `has_many` other ActiveRecords, but what about the rest of us? SilverSpoon lets ActiveRecord objects `has_many` Non-ActiveRecord objects, or for Non-ActiveRecord objects to `has_many` other Non-ActiveRecord objects.  
+
+For the people!
+
+## Suppose you have a plain old ActiveModel
+
+    class BankAccount
+      class << self
+        def find(args)
+          HTTP Request...
+          an arbitrary service...
+          or some awful local Modeling logic...
+          ...
+        end
+      end
+    end
+
+## And another Object that bares an association to it
+
+    class User < ActiveRecord::Base
+      extend SilverSpoon::ActiveConcern
+
+      has_many :bank_accounts
+    end
+
+## Now make calls a la ActiveRecord Association
+
+    user = User.new
+
+    user.bank_accounts
+
+The referencing class does not have to be an ActiveRecord object.  It simply needs to respond to a `find` method as you would expect. Having an `@id` or `to_params` would be useful as well in most cases.  It would also be nice if there was a `save` method, if you're going to be doing something like that.
+
+The `find` method may receive the id from the referring object to associate the two.
+

data/Rakefile

@@ -0,0 +1,44 @@
+lib_path = File.expand_path('../../lib', __FILE__)
+#ENV['RACK_ENV'] = ENV['RAILS_ENV'] = ENV['ODDZ_ENV'] ||= "development"
+#require 'config/boot'
+#Bundler::GemHelper.install_tasks if defined?(Bundler)
+#require 'active_record'
+#
+require 'rspec/core'
+require 'rspec/core/rake_task'
+#require 'rspec/core/rake_task'
+require 'active_record'
+#
+#Dir[File.join(File.dirname(__FILE__), 'lib/tasks/*.rake')].each {|f| load f }
+#Dir[File.join(File.dirname(__FILE__), 'lib/tasks/**/*.rake')].each {|f| load f }
+#include ActiveRecord::Tasks
+#
+##Database
+#dbconfig ||= YAML::load(ERB.new(File.read('config/database.yml')).result)
+#dbenv = dbconfig[ENV["ODDZ_ENV"]]
+#ENV["DATABASE_URL"] ||= "postgres://#{dbenv["username"]}:#{dbenv["password"]}@#{dbenv["host"]}:#{dbenv["port"]}/#{dbenv["database"]}"
+#
+#DatabaseTasks.env = ENV["ODDZ_ENV"]
+#DatabaseTasks.seed_loader = SeedLoader.new
+#DatabaseTasks.database_configuration = dbconfig
+#DatabaseTasks.db_dir = 'db'
+#DatabaseTasks.migrations_paths = 'db/migrate'
+#DatabaseTasks.root = File.dirname(__FILE__)
+#load 'active_record/railties/databases.rake'
+#
+desc "create database"
+task :create_db do
+  
+
+
+  #intentionally nothing
+end
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+task :default => :spec
+
+#ActiveRecord::Base.configurations = dbconfig
+#ActiveRecord::Base.establish_connection(
+#  :adapter   => "sqlite3",
+#  :database  => "activeworkaround.db"
+#)

data/lib/meek.rb

@@ -0,0 +1,7 @@
+require 'active_support'
+
+require 'meek/errors'
+require 'meek/concern'
+require 'meek/active_concern'
+require 'meek/proxy_association'
+require 'meek/collection_proxy'

data/lib/meek/active_concern.rb

@@ -0,0 +1,13 @@
+#presume it's an active record compliant object,
+# abstract
+module Meek
+  module ActiveConcern
+
+    class << self
+      def self.relation_delegate_class(_args)
+        Meek::CollectionProxy
+      end
+    end
+
+  end
+end

data/lib/meek/collection_proxy.rb

@@ -0,0 +1,58 @@
+module Meek
+
+  class CollectionProxy
+    attr_accessor :owner, :model, :proxy_association
+
+    def initialize model, association
+      @proxy_association = Meek::ProxyAssociation.new(model, association)
+    end
+
+    delegate :[], :first, :second, :third, :fourth, :fifth, :forty_two,
+      :find, :select,
+      :last, :take, :count, :size, :length, :empty?, :any?, :many?, :include?,  
+      :create, :create!, :build, :new,
+      to: :proxy_association
+
+    #replace, delete_all, destroy_all, delete, destroy, distinct, uniq, 
+
+    def concat new
+      proxy_association.concat(new)
+    end
+
+    def <<(*records)
+      records.map {|record| record.save }
+      proxy_association.concat(records) && self
+    end
+    alias_method :push, :<<
+    alias_method :append, :<<
+
+    def prepend(*args)
+      raise NoMethodError, "prepend on association is not defined. Please use << or append"
+    end
+
+    # Equivalent to +delete_all+. The difference is that returns +self+, instead
+    # of an array with the deleted objects, so methods can be chained. See
+    # +delete_all+ for more information.
+    # Note that because +delete_all+ removes records by directly
+    # running an SQL query into the database, the +updated_at+ column of
+    # the object is not changed.
+    def clear
+      delete_all
+      self
+    end
+
+    # Reloads the collection from the database. Returns +self+.
+    def reload
+      proxy_association.reload
+      self
+    end
+
+    # Unloads the association. Returns +self+.
+    def reset
+      proxy_association.reset
+      proxy_association.reset_scope
+      self
+    end
+
+  end
+end

data/lib/meek/concern.rb

@@ -0,0 +1,52 @@
+# presume it's an active record compliant object,
+# abstract
+module Meek
+  module Concern
+
+    def has_many(name, args={})
+      @@active_workaround_args ||= {}
+      @@active_workaround_args[:has_many] ||= {}
+      @@active_workaround_args[:has_many][name] = args
+      @@active_workaround_args[:has_many][name][:_attribute_name] = name
+
+      define_method(name) do
+        #return instance_variable_get(name) if does_cache && !instance_variable_get(name).nil?
+
+        args= @@active_workaround_args[:has_many][name]
+        msg = {}
+
+        foreign_key = args[:foreign_key] || ActiveSupport::Inflector.foreign_key(self.class.name)
+        msg[foreign_key] = respond_to?(:to_param) ? to_param : @id
+
+        klass_title = ActiveSupport::Inflector.classify( msg[:class_name] || name )
+        klass = args[:class] || ActiveSupport::Inflector.constantize(klass_title)
+
+        response = klass.find(:all, msg)
+        #instance_variable_set(name, response) if does_cache
+        response
+      end
+    end
+
+    def belongs_to(name, args={})
+      @@active_workaround_args ||= {}
+      @@active_workaround_args[:belongs_to] ||= {}
+      @@active_workaround_args[:belongs_to][name] = args
+      @@active_workaround_args[:belongs_to][name][:_attribute_name] = name
+
+      define_method(name) do
+
+        args= @@active_workaround_args[:belongs_to][name]
+        msg = {}
+
+        foreign_key = args[:foreign_key] || :id
+        msg[foreign_key] = respond_to?(:to_param) ? to_param : @id
+
+        klass_title = ActiveSupport::Inflector.classify(name)
+        klass = args[:class] || ActiveSupport::Inflector.constantize(klass_title)
+
+        klass.find(msg)
+      end
+    end
+
+  end
+end

data/lib/meek/errors.rb

@@ -0,0 +1,3 @@
+module Meek
+  class NoDomain < StandardError; end
+end

data/lib/meek/proxy_association.rb

@@ -0,0 +1,51 @@
+module Meek
+
+  class ProxyAssociation
+
+    attr_accessor :items
+
+    delegate :[], :first, :second, :third, :fourth, :fifth, :forty_two,
+      :find, :select,
+      :last, :take, :count, :size, :length, :empty?, :any?, :many?, :include?,  
+      to: :items
+
+    def initialize( model, association )
+      @owner = association.owner
+      @model = model
+      reload
+    end
+
+    def create(args)
+      args[foriegn_key(@owner)] = @owner.to_param
+      @model.create(args)
+    end
+
+    def create!(args)
+      args[foriegn_key(@owner)] = @owner.to_param
+      @model.create!(args)
+    end
+
+    def build(args)
+      args[foriegn_key(@owner)] = @owner.to_param
+      @model.build(args)
+    end
+    alias_method :new, :build
+
+    def concat(new)
+      @items.concat(new)
+    end
+
+    def reload
+      @items = @model.find(:all, foriegn_key(@owner) => @owner.to_param)
+    end
+
+    #def reset
+    #end
+
+    #def reset_scope
+    #end
+
+    def foriegn_key(klass); ActiveSupport::Inflector.foreign_key(klass.class.name); end
+
+  end
+end

data/lib/meek/version.rb

@@ -0,0 +1,3 @@
+module Meek
+  VERSION="0.0.6"
+end

data/spec/meek/active_concern_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe(Meek::ActiveConcern) do
+
+  describe("has_many") do 
+
+    it("creates an object that responds to association") {
+      dummy = User.create(name: "bob")
+      expect(FundingInstrument).to receive(:find).with(:all, "user_id"=>dummy.id.to_s)
+      dummy.funding_instruments
+    }
+
+    it("returns as expected") {
+      dummy = User.create(name: "bob")
+      expect(dummy.funding_instruments).to be_a(Meek::CollectionProxy)
+      expect(dummy.funding_instruments[0]).to be(:a)
+
+      expect(dummy.funding_instruments.first).to be(:a)
+
+      [:size, :length, :count].each do |method|
+        expect(dummy.funding_instruments.send(method)).to be(2)
+      end
+
+    }
+
+    describe("new") do
+
+      it("builds") {
+        args = {:a => :b}
+        dummy = User.create(name: "bob")
+        expect(FundingInstrument).to receive(:build).with(args)
+        dummy.funding_instruments.build(args)
+      }
+
+      it("creates") {
+        args = {:a => :b}
+        dummy = User.create(name: "bob")
+        expect(FundingInstrument).to receive(:create).with(args)
+        dummy.funding_instruments.create(args)
+      }
+
+      it("creates!") {
+        args = {:a => :b}
+        dummy = User.create(name: "bob")
+        expect(FundingInstrument).to receive(:create!).with(args)
+        dummy.funding_instruments.create!(args)
+      }
+
+      it("concats") {
+        dummy = User.create(name: "bob")
+
+        child = Array.wrap( FundingInstrument.new() )
+        expect(dummy.funding_instruments.size).to eq(2)
+        dummy.funding_instruments.concat( child )
+        expect(dummy.funding_instruments.size).to eq(3)
+      }
+
+      it("pushes") {
+        dummy = User.create(name: "bob")
+
+        child = FundingInstrument.new()
+        expect(dummy.funding_instruments.size).to eq(2)
+        dummy.funding_instruments << child 
+        expect(dummy.funding_instruments.size).to eq(3)
+        dummy.funding_instruments.push child 
+        expect(dummy.funding_instruments.size).to eq(4)
+        dummy.funding_instruments.append child 
+        expect(dummy.funding_instruments.size).to eq(5)
+      }
+
+    end
+
+  end
+
+end

data/spec/meek/concern_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe(Meek::Concern) do
+
+  describe("has_many") do 
+
+    describe("finds a foreign_id") do
+
+      #it("prefers to_param") {
+      #  dummy = User.new
+      #  expect(FundingInstrument).to receive(:find).with(:all, "dummy_id"=>1)
+      #  dummy.funding_instruments
+      #}
+
+      #it("defaults to @id") {
+      #  dummy = UserWithoutToParam.new
+
+      #  #expect(FundingInstrument).to receive(:find).with(:all, "dummy_without_to_param_id"=>1)
+      #  #dummy.funding_instruments
+      #}
+
+      it("doesn't croak on no id") { skip("I'm lazy, put an id on it")
+        dummy = HorribleObject.new
+        #expect(FundingInstrument).to receive(:find).with(:all, {})
+        #dummy.funding_instruments
+      }
+
+    end
+
+  end
+
+  describe("belongs_to") do
+
+    it("creates an object that responds to association") {
+      dummy = SubservientDummy.new
+      #expect(ParentObject).to receive(:find).with(id:1)
+      dummy.parent_object
+    }
+
+    it("returns as expected") {
+      dummy = SubservientDummy.new
+      #expect(dummy.parent_object).to eq([:a, :b, :c])
+    }
+
+  end
+
+end

data/spec/models/dummy.rb

@@ -0,0 +1,49 @@
+class FundingInstrument
+  # I'm a fake ActiveModel class!
+  def save
+    @persisted = true
+  end
+
+  # I should minimally respond to the #find method
+  class << self
+    def find(*args)
+      [:a, :b]
+    end
+
+    def relation_delegate_class(_args)
+      Meek::CollectionProxy
+    end
+  end
+end
+
+class ParentObject
+  extend Meek::ActiveConcern
+  def self.find(args)
+    [:a, :b, :c]
+  end
+end
+
+class User < ActiveRecord::Base
+
+  has_many :funding_instruments
+
+end
+
+class UserWithoutToParam < User
+
+end
+
+class HorribleObject < User
+
+end
+
+class SubservientDummy
+  extend Meek::Concern
+
+  def initialize
+    @id = 1
+  end
+
+  belongs_to :parent_object
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+lib_path = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+require 'active_record'
+require 'meek'
+
+ActiveRecord::Base.establish_connection(
+  :adapter   => "sqlite3",
+  :database  => "./db/test.sqlite3"
+)
+
+# in spec/support/ and its subdirectories.
+Dir.glob(File.join(File.dirname(__FILE__), './models', '*.rb')).each { |f| require f}
+Dir.glob(File.join(File.dirname(__FILE__), 'support', '*.rb')).each { |f| require f}

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: meek
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Trevor Grayson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-07-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  prerelease: false
+  type: :development
+description: This may go from ActiveRecord to Object or Object to ActiveRecord
+email:
+- trevor@trevorgrayson.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/meek.rb
+- lib/meek/active_concern.rb
+- lib/meek/collection_proxy.rb
+- lib/meek/concern.rb
+- lib/meek/errors.rb
+- lib/meek/proxy_association.rb
+- lib/meek/version.rb
+- spec/meek/active_concern_spec.rb
+- spec/meek/concern_spec.rb
+- spec/models/dummy.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+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: Add has_many methods for non ActiveRecord associations.
+test_files: []
+has_rdoc: