ninja-model 0.4.2

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1 @@
+# Ninja-model

data/Rakefile

@@ -0,0 +1,38 @@
+require 'bundler'
+Bundler.setup
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+end
+
+desc 'Run specs with documentation format'
+RSpec::Core::RakeTask.new(:specd) do |t|
+  t.verbose = false
+  t.rspec_opts = '--format d'
+end
+
+Rake::RDocTask.new do |r|
+  r.rdoc_dir = 'doc/html'
+  r.main = "README.md"
+  r.rdoc_files.include('README.md', 'lib/**/*.rb')
+  r.rdoc_files.exclude('lib/generators/**/*')
+end
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:rcov) do |t|
+    t.rcov = true
+    t.rcov_opts = %w{--text-report --sort coverage}
+    t.rcov_opts << %w{--exclude gems\/,spec\/}
+  end
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format progress"
+end

data/lib/generators/ninja_model/model/model_generator.rb

@@ -0,0 +1,19 @@
+require 'generators/ninja_model'
+
+module NinjaModel
+  module Generators
+    class ModelGenerator < NamedBase
+      argument :attributes, :type => :array, :default => [], :banner => 'field:type field:type'
+
+      def initialize(*args, &block)
+        super
+      end
+
+      def create_model
+        template 'model.rb', "app/models/#{singular_name}.rb"
+      end
+
+      hook_for :test_framework, :as => :model
+    end
+  end
+end

data/lib/generators/ninja_model/model/templates/model.rb

@@ -0,0 +1,7 @@
+require 'ninja_model'
+
+class <%= class_name %> < NinjaModel::Base
+<%- attributes.each do |a| -%>
+  attribute :<%= a.name %>, :<%= a.type %>
+<%- end -%>
+end

data/lib/generators/ninja_model/scaffold/scaffold_generator.rb

@@ -0,0 +1,69 @@
+require 'generators/ninja_model'
+
+module NinjaModel
+  module Generators
+    class ScaffoldGenerator < ModelGenerator
+      argument :attributes, :type => :array, :default => [], :banner => 'field:type field:type'
+
+      def initialize(*args, &block)
+        super
+
+        @controller_actions = []
+        actions.each do |action|
+
+        end
+      end
+
+      def create_controller
+        template 'controller.rb', "app/controllers/#{plural_name}_controller.rb"
+        unless options.skip_helper?
+          template 'helper.rb', "app/helpers/#{plural_name}_helper.rb"File.join(plugin_path, 'app/helpers',
+                                          "#{plural_file_path}_helper.rb")
+        end
+
+        controller_actions.each do |action|
+          if %w[index show new edit].include?(action)
+            template "views/#{action}.html.erb", File.join(plugin_path,
+                                                           "app/views/#{plural_name}/#{action}.html.erb")
+
+
+          end
+        end
+        template 'views/_form.html.erb', File.join(plugin_path, "app/views/#{plural_name}/_form.html.erb")
+
+        if class_path.length < 0
+          plugin_route("resources #{plural_file_name.to_sym.inspect},
+                       :controller => '#{(class_path + [plural_name]).join('/')}")
+        else
+          plugin_route("resources #{plural_name.to_sym.inspect}")
+        end
+      end
+
+      protected
+
+      attr_reader :controller_actions
+
+      def controller_methods(dir)
+        controller_actions.map do |action|
+          read_template("#{dir}/#{action}.rb")
+        end.join("\n").strip
+      end
+
+      def read_template(relative_path)
+        ERB.new(File.read(find_in_source_paths(relative_path)), nil, '-').result(binding)
+      end
+
+      def all_actions
+        %w[index show new create edit update destroy]
+      end
+
+      def action?(name)
+        controller_actions.include? name.to_s
+      end
+
+      def actions?(*names)
+        names.all? { |name| action? name }
+      end
+    end
+  end
+end

data/lib/generators/ninja_model.rb

@@ -0,0 +1,12 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module NinjaModel
+  module Generators
+    class NamedBase < Rails::Generators::NamedBase
+      def self.source_root
+        @ninja_model_source_root ||= File.join(File.dirname(__FILE__), 'ninja_model', generator_name, 'templates')
+      end
+    end
+  end
+end

data/lib/ninja-model.rb

@@ -0,0 +1 @@
+require 'ninja_model'

data/lib/ninja_model/adapters/abstract_adapter.rb

@@ -0,0 +1,63 @@
+module NinjaModel
+  module Adapters
+    class AbstractAdapter
+      class << self
+        def instance
+          @instance ||= new
+        end
+      end
+
+      def initialize(config, logger = nil)
+        @active = nil
+        @config, @logger = config, logger
+      end
+
+      def adapter_name
+        'Abstract'
+      end
+
+      def persistent_connection?
+        true
+      end
+
+      def active?
+        @active != false
+      end
+
+      def reconnect!
+        @active = true
+      end
+
+      def disconnect!
+        @active = false
+      end
+
+      def reset!
+      end
+
+      def verify!
+        reconnect! unless active?
+      end
+
+      def create(model)
+        false
+      end
+
+      def read(query)
+        nil
+      end
+
+      def update(model)
+        false
+      end
+
+      def destroy(model)
+        false
+      end
+
+      def raw_connection
+        @connection
+      end
+    end
+  end
+end

data/lib/ninja_model/adapters/adapter_manager.rb

@@ -0,0 +1,67 @@
+module NinjaModel
+  module Adapters
+    class AdapterManager
+      attr_reader :adapter_pools
+
+      def initialize(pools = {})
+        @adapter_pools = pools
+      end
+
+      def create_adapter(name, spec)
+        @adapter_pools[name] = Adapters::AdapterPool.new(spec)
+      end
+
+      def release_active_adapters!
+        @adapter_pools.each_value do |pool|
+          pool.release_adapter
+        end
+      end
+
+      def release_reloadable_adapters!
+        @adapter_pools.each_value do |pool|
+          pool.shutdown_reloadable_adapters!
+        end
+      end
+
+      def release_all_adapters!
+        @adapter_pools.each_value do |pool|
+          pool.shutdown!
+        end
+      end
+
+      def retrieve_adapter(klass)
+        pool = retrieve_adapter_pool(klass)
+        (pool && pool.instance) or raise StandardError
+      end
+
+      def remove_adapter(klass)
+        pool = @adapter_pools[klass.name]
+        return nil unless pool
+        @adapter_pools.delete_if { |key, value| value == pool }
+        pool.shutdown!
+        pool.spec.config
+      end
+
+      def retrieve_adapter_pool(klass)
+        pool = @adapter_pools[klass.name]
+        return pool if pool
+        return nil if NinjaModel::Base == klass
+        retrieve_adapter_pool klass.superclass
+      end
+    end
+
+    class AdapterManagement
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        unless env.key?('rake.test')
+          NinjaModel::Base.clear_active_instances!
+        end
+      end
+    end
+  end
+end

data/lib/ninja_model/adapters/adapter_pool.rb

@@ -0,0 +1,128 @@
+module NinjaModel
+  module Adapters
+    class AdapterPool
+      attr_reader :spec, :instances
+      def initialize(spec)
+        @spec = spec
+        @instances = []
+        @checked_out_instances = []
+        @assigned_instances = {}
+        @instance_mutex = Monitor.new
+        @instance_queue = @instance_mutex.new_cond
+        @max_size = 5
+        @timeout = 3
+      end
+
+      def instance
+        NinjaModel.logger.debug("instance called for #{current_instance_id}")
+        @assigned_instances[current_instance_id] ||= checkout
+      end
+
+      def release_instance(with_id = current_instance_id)
+        inst = @assigned_instances.delete(with_id)
+        checkin inst if inst
+      end
+
+      def with_instance
+        instance_id = current_instance_id
+        fresh_instance = true unless @assigned_instances[instance_id]
+        yield instance
+      ensure
+        release_instance(instance_id) if fresh_instance
+      end
+
+      def connected?
+        !@instances.empty?
+      end
+
+      private
+
+      def clear_stale_cached_instances!
+        NinjaModel.logger.debug("clearing stale instances: #{@assigned_instances.keys}")
+        keys = @assigned_instances.keys - Thread.list.find_all { |t|
+          t.alive?
+        }.map { |thread| thread.object_id }
+        keys.each do |key|
+          NinjaModel.logger.debug("Checking in stale connection for #{key}")
+          checkin @assigned_instances[key]
+          @assigned_instances.delete(key)
+        end
+      end
+
+      def checkout
+        NinjaModel.logger.debug("checking out a connection for #{current_instance_id}")
+        @instance_mutex.synchronize do
+          loop do
+            instance = if @checked_out_instances.size < @instances.size
+                     checkout_existing_instance
+                   elsif @instances.size < @max_size
+                     checkout_new_instance
+                   end
+            return instance if instance
+
+            # If we're here, we didn't get a valid instance
+            @instance_queue.wait(@timeout)
+            if (@checked_out_instances.size < @instances.size)
+              next
+            else
+              NinjaModel.logger.debug("Connection pool full.  Clearing cached instances.")
+              clear_stale_cached_instances!
+              if @max_size == @checked_out_instances.size
+                NinjaModel.logger.warn("Connection pool full?")
+                NinjaModel.logger.warn("@checked_out_instances: #{@checked_out_instances.inspect}")
+                NinjaModel.logger.warn("@assigned_instances: #{@assigned_instances.inspect}")
+                raise ConnectionTimeoutError, "[ninja-model] *ERROR* Could not obtain an adapter instance within #{@timeout} seconds.  The max adapter pool size is currently #{@max_size}...consider increasing it."
+              end
+            end
+          end
+        end
+      end
+
+      def checkin(inst)
+        @instance_mutex.synchronize do
+          @checked_out_instances.delete inst
+          @instance_queue.signal
+        end
+      end
+
+      def new_instance
+        NinjaModel::Base.send(spec.adapter_method, spec.config)
+      end
+
+      def current_instance_id
+        Thread.current.object_id
+      end
+
+      def checkout_new_instance
+        i = new_instance
+        @instances << i
+        checkout_and_verify(i)
+      end
+
+      def checkout_existing_instance
+        i = (@instances - @checked_out_instances).first
+        checkout_and_verify(i)
+      end
+
+      def checkout_and_verify(inst)
+        inst.verify!
+        @checked_out_instances << inst
+        inst
+      end
+    end
+
+    class AdapterManagement
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        unless env.key?('rask.test')
+          NinjaModel::Base.clear_active_instances!
+        end
+      end
+    end
+  end
+end

data/lib/ninja_model/adapters/adapter_specification.rb

@@ -0,0 +1,11 @@
+module NinjaModel
+  module Adapters
+    class AdapterSpecification
+      attr_accessor :config, :adapter_method
+
+      def initialize(config, adapter_method)
+        @config, @adapter_method = config, adapter_method
+      end
+    end
+  end
+end

data/lib/ninja_model/adapters.rb

@@ -0,0 +1,70 @@
+require 'active_support'
+
+module NinjaModel
+
+  module Adapters
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    autoload :AdapterSpecification
+    autoload :AdapterManager
+    autoload :AdapterPool
+    autoload :AbstractAdapter
+
+    class << self
+    end
+  end
+
+  class Base
+    class_attribute :adapter_manager
+    self.adapter_manager = NinjaModel::Adapters::AdapterManager.new
+
+    def adapter
+      self.class.adapter
+    end
+
+    def self.set_adapter(spec = nil)
+      case spec
+      when nil
+        raise AdapterNotSpecified unless defined?(Rails.env)
+        set_adapter(Rails.env)
+      when AdapterSpecification
+        self.adapter_manager.create_adapter(name, spec)
+      when Symbol, String
+        if config = NinjaModel.configuration.specs[spec.to_s]
+          set_adapter(config)
+        else
+          raise AdapterNotSpecified, "#{spec} is not configured"
+        end
+      else
+        spec = spec.symbolize_keys
+        unless spec.key?(:adapter) then raise AdapterNotSpecified, "configuration does not specify adapter" end
+        begin
+          require File.join(NinjaModel.configuration.adapter_path, "#{spec[:adapter]}_adapter")
+        rescue LoadError => e
+          raise "Please install (or create) the #{spec[:adapter]} adapter.  Search path is #{NinjaModel.configuration.adapter_path}"
+        end
+        adapter_method = "#{spec[:adapter]}_adapter"
+        if !respond_to?(adapter_method)
+          raise AdapterNotFound, "ninja configuration specifies nonexistent #{spec[:adapter]} adapter"
+        end
+        shutdown_adapter
+        set_adapter(AdapterSpecification.new(spec, adapter_method))
+      end
+    end
+
+    class << self
+      def adapter
+        retrieve_adapter
+      end
+
+      def retrieve_adapter
+        adapter_manager.retrieve_adapter(self)
+      end
+
+      def shutdown_adapter(klass = self)
+        adapter_manager.remove_adapter(klass)
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/active_record_proxy.rb

@@ -0,0 +1,53 @@
+
+module NinjaModel
+  module Associations
+    class ActiveRecordProxy
+      def initialize(ninja_model)
+        @klass = ninja_model
+        @klass.class_eval do
+          def proxy
+            @proxy ||= begin
+              self.class.proxy.instance(self)
+            end
+            @proxy.attributes = self.attributes.delete_if { |k,v| k.eql?('id') }
+            @proxy
+          end
+        end
+
+        @proxy_klass = ninja_model.parent.const_set("#{@klass.model_name}Proxy", Class.new(ActiveRecord::Base))
+        @proxy_klass.class_eval do
+          cattr_accessor :columns
+          self.columns = []
+          def self.column(name, sql_type = nil, default = nil)
+            self.columns << ActiveRecord::ConnectionAdapters::Column.new(name, nil, sql_type.to_s, default)
+          end
+        end
+
+        @klass.model_attributes.each do |attr|
+          @proxy_klass.send :column, attr.name, attr.type, attr.default
+        end
+      end
+
+      def instance(obj)
+        proxy = @proxy_klass.new
+        proxy.send :init_with, {'attributes' => obj.attributes}
+        proxy
+      end
+
+      def handle_association(macro, association_id, options)
+        unless macro.eql?(:belongs_to)
+          options = {:foreign_key => derive_foreign_key}.merge(options)
+        end
+
+        @proxy = nil
+        @proxy_klass.send macro, association_id, options
+      end
+
+      private
+
+      def derive_foreign_key
+        "#{@klass.name.underscore}_id".to_sym
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/association_proxy.rb

@@ -0,0 +1,8 @@
+require 'active_record/associations/association_proxy'
+
+module NinjaModel
+  module Associations
+    class AssociationProxy < ActiveRecord::Associations::AssociationProxy
+    end
+  end
+end

data/lib/ninja_model/associations/belongs_to_association.rb

@@ -0,0 +1,31 @@
+module NinjaModel
+  module Associations
+    class BelongsToAssociation < AssociationProxy
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+      end
+
+      def replace(record)
+        if record.nil?
+          @target = @owner[@reflection.primary_key_name] = nil
+        else
+          @target = (AssociationProxy === record ? record.target : record)
+          @owner[@reflection.primary_key_name] = record_id(record) if record.persisted?
+          @updated = true
+        end
+        loaded
+        record
+      end
+
+      private
+
+      def find_target
+        @reflection.klass.scoped.where(@reflection.association_foreign_key => @owner.send(@reflection.primary_key_name)).first
+      end
+
+      def record_id(record)
+        record.send(@reflection.options[:primary_key] || :id)
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/has_many_association.rb

@@ -0,0 +1,36 @@
+module NinjaModel
+  module Associations
+    class HasManyAssociation
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+        @relation = reflection.klass.scoped.where(reflection.primary_key_name.to_sym.eq(owner.id))
+      end
+
+      delegate :each, :collect, :map, :to_a, :size, :blank?, :empty?, :to => :relation
+
+      def method_missing(method, *args)
+        if @relation.respond_to?(method)
+          @relation.send(method, *args)
+        else
+          super
+        end
+      end
+
+      def relation
+        @relation
+      end
+
+      def inspect
+        @relation.to_a.inspect
+      end
+
+      def blank?
+        @relation.blank?
+      end
+
+      def to_ary
+        @relation.to_a
+      end
+    end
+  end
+end

data/lib/ninja_model/associations/has_one_association.rb

@@ -0,0 +1,19 @@
+module NinjaModel
+  module Associations
+    class HasOneAssociation < AssociationProxy
+
+      def create(attrs = {}, replace_existing = true)
+        new_record
+      end
+
+      private
+
+      def find_target
+        @reflection.klass.scoped.where(@reflection.primary_key_name => @owner.send(:id)).first
+      end
+
+      def new_record(replace_existing)
+      end
+    end
+  end
+end