mark_mapper 0.0.1

data/lib/mark_mapper/railtie.rb

@@ -0,0 +1,52 @@
+require "mark_mapper"
+require "rails"
+require "active_model/railtie"
+
+# Need the action_dispatch railtie to have action_dispatch.rescu_responses initialized correctly
+require "action_dispatch/railtie"
+
+module MarkMapper
+  # = MarkMapper Railtie
+  class Railtie < Rails::Railtie
+
+    config.mark_mapper = ActiveSupport::OrderedOptions.new
+
+    # Rescue responses similar to ActiveRecord.
+    # For rails 3.0 and 3.1
+    if Rails.version < "3.2"
+      ActionDispatch::ShowExceptions.rescue_responses['MarkMapper::DocumentNotFound']  = :not_found
+      ActionDispatch::ShowExceptions.rescue_responses['MarkMapper::InvalidKey']        = :unprocessable_entity
+      ActionDispatch::ShowExceptions.rescue_responses['MarkMapper::InvalidScheme']     = :unprocessable_entity
+      ActionDispatch::ShowExceptions.rescue_responses['MarkMapper::NotSupported']      = :unprocessable_entity
+    else
+      # For rails 3.2 and 4.0
+      config.action_dispatch.rescue_responses.merge!(
+          'MarkMapper::DocumentNotFound'  => :not_found,
+          'MarkMapper::InvalidKey'        => :unprocessable_entity,
+          'MarkMapper::InvalidScheme'     => :unprocessable_entity,
+          'MarkMapper::NotSupported'      => :unprocessable_entity
+        )
+    end
+
+    rake_tasks do
+      load "mark_mapper/railtie/database.rake"
+    end
+
+    initializer "mark_mapper.set_configs" do |app|
+      ActiveSupport.on_load(:mark_mapper) do
+        app.config.mark_mapper.each do |k,v|
+          send "#{k}=", v
+        end
+      end
+    end
+
+    # This sets the database configuration and establishes the connection.
+    initializer "mark_mapper.initialize_database" do |app|
+      config_file = Rails.root.join('config/marklogic.yml')
+      if config_file.file?
+        config = YAML.load(ERB.new(config_file.read).result)
+        MarkMapper.setup(config, Rails.env, :logger => Rails.logger)
+      end
+    end
+  end
+end

data/lib/mark_mapper/railtie/database.rake

@@ -0,0 +1,65 @@
+namespace :db do
+  unless Rake::Task.task_defined?("db:drop")
+    desc 'Drops all the collections for the database for the current Rails.env'
+    task :drop => :environment do
+      MarkMapper.database.collections.select {|c| c.name !~ /\Asystem\./ }.each(&:drop)
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:seed")
+    # if another ORM has defined db:seed, don't run it twice.
+    desc 'Load the seed data from db/seeds.rb'
+    task :seed => :environment do
+      seed_file = File.join(Rails.root, 'db', 'seeds.rb')
+      load(seed_file) if File.exist?(seed_file)
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:setup")
+    desc 'Create the database, and initialize with the seed data'
+    task :setup => [ 'db:create', 'db:seed' ]
+  end
+
+  unless Rake::Task.task_defined?("db:reseed")
+    desc 'Delete data and seed'
+    task :reseed => [ 'db:drop', 'db:seed' ]
+  end
+
+  unless Rake::Task.task_defined?("db:create")
+    task :create => :environment do
+      # noop
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:migrate")
+    task :migrate => :environment do
+      # noop
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:schema:load")
+    namespace :schema do
+      task :load do
+        # noop
+      end
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:test:prepare")
+    namespace :test do
+      task :prepare => :environment do
+        MarkMapper.connect('test')
+        MarkMapper.database.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+        MarkMapper.connect(Rails.env)
+      end
+    end
+  end
+
+  desc 'Load indexes from db/indexes.rb'
+  task :index => :environment do
+    indexes = File.join(Rails.root, 'db', 'indexes.rb')
+    load(indexes) if File.exist?(indexes)
+  end
+end
+
+task 'test:prepare' => 'db:test:prepare'

data/lib/mark_mapper/translation.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+module MarkMapper
+  module Translation
+    include ActiveModel::Translation
+
+    def i18n_scope
+      :mark_mapper
+    end
+  end
+end

data/lib/mark_mapper/version.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+module MarkMapper
+  Version = '0.0.1'
+end

data/lib/rails/generators/mark_mapper/config/config_generator.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module MarkMapper
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      desc 'creates the MarkMapper configuration at config/marklogic.yml'
+
+      argument :database_name, :type => :string, :optional => true
+
+      def self.source_root
+        @source_root ||= File.expand_path('../templates', __FILE__)
+      end
+
+      def create_config_file
+        template 'marklogic.yml', File.join('config', 'marklogic.yml')
+      end
+
+      protected
+
+        def app_name
+          @app_name ||= defined_app_const_base? ? defined_app_name : File.basename(destination_root)
+        end
+
+        def defined_app_name
+          defined_app_const_base.underscore
+        end
+
+        def defined_app_const_base
+          Rails.respond_to?(:application) && defined?(Rails::Application) &&
+            Rails.application.is_a?(Rails::Application) && Rails.application.class.name.sub(/::Application$/, '')
+        end
+
+        alias :defined_app_const_base? :defined_app_const_base
+
+    end
+  end
+end

data/lib/rails/generators/mark_mapper/config/templates/marklogic.yml

@@ -0,0 +1,19 @@
+defaults: &defaults
+  host: 127.0.0.1
+  port: 27017
+
+development:
+  <<: *defaults
+  database: <%= database_name || app_name %>_development
+
+test:
+  <<: *defaults
+  database: <%= database_name || app_name %>_test
+  w: 0
+
+# set these environment variables on your prod server
+production:
+  <<: *defaults
+  database: <%= database_name || app_name %>
+  username: <%%= ENV['MARKLOGIC_USERNAME'] %>
+  password: <%%= ENV['MARKLOGIC_PASSWORD'] %>

data/lib/rails/generators/mark_mapper/model/model_generator.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module MarkMapper
+  module Generators
+    class ModelGenerator < Rails::Generators::NamedBase
+      desc 'Creates a markmapper model'
+
+      argument :name, :type => :string
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      check_class_collision
+
+      class_option :timestamps, :type => :boolean
+      class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
+
+      def self.source_root
+        @source_root ||= File.expand_path("../templates", __FILE__)
+      end
+
+      def create_model_file
+        template 'model.rb', File.join('app/models', class_path, "#{file_name}.rb")
+      end
+
+      hook_for :test_framework
+
+      protected
+
+        def parent_class_name
+          options[:parent]
+        end
+
+        # Rails 3.0.X compatibility
+        unless methods.include?(:module_namespacing)
+          def module_namespacing(&block)
+            yield if block
+          end
+        end
+    end
+  end
+end

data/lib/rails/generators/mark_mapper/model/templates/model.rb

@@ -0,0 +1,17 @@
+<%- module_namespacing do -%>
+<%- if parent_class_name.present? -%>
+class <%= class_name %> < <%= parent_class_name.classify %>
+<%- else -%>
+class <%= class_name %>
+  include MarkMapper::Document
+<%- end -%>
+
+<%- attributes.each do |attribute| -%>
+  key :<%= attribute.name %>, <%= attribute.type.to_s.camelcase %>
+<% end -%>
+<%- if options[:timestamps] -%>
+  timestamps!
+<%- end -%>
+
+end
+<%- end -%>

data/spec/config/mark_mapper.yml

@@ -0,0 +1,6 @@
+test:
+  app_name: markmapper-application-test
+  host: <%=ENV["MARKMAPPER_SPEC_HOST"]%>
+  port: <%=ENV["MARKMAPPER_SPEC_PORT"]%>
+  username: <%=ENV["MARKMAPPER_SPEC_USER"]%>
+  password: <%=ENV["MARKMAPPER_SPEC_PASSWORD"]%>

data/spec/examples_spec.rb

@@ -0,0 +1,25 @@
+describe "The Examples" do
+
+  before do
+    @previous = MarkMapper::Plugins::IdentityMap.enabled
+  end
+
+  after do
+    MarkMapper::Plugins::IdentityMap.enabled = @previous
+  end
+
+  file = File.dirname(__FILE__) + "/../examples/**/*.rb"
+  puts file
+  Dir[file].each do |f|
+    it "should run #{f}" do
+
+      expect {
+
+        Object.send(:remove_const, :User) if Object.constants.include?(:User)
+
+        require f
+      }.to_not raise_error
+
+    end
+  end
+end

data/spec/functional/accessible_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe "Accessible" do
+  context 'A document with accessible attributes' do
+    before do
+      @doc_class = Doc do
+        key :name, String
+        key :admin, Boolean, :default => false
+
+        attr_accessible :name
+      end
+
+      @doc = @doc_class.create(:name => 'Steve Sloan')
+    end
+
+    it 'should have accessible attributes class method' do
+      @doc_class.accessible_attributes.should == [:name].to_set
+    end
+
+    it "should default accessible attributes to nil" do
+      Doc().accessible_attributes.should be_nil
+    end
+
+    it "should have accessible_attributes instance method" do
+      @doc.accessible_attributes.should equal(@doc_class.accessible_attributes)
+    end
+
+    it "should raise error if there are protected attributes" do
+      doc = Doc('Post')
+      doc.attr_protected :admin
+      lambda { doc.attr_accessible :name }.
+        should raise_error(/Declare either attr_protected or attr_accessible for Post/)
+    end
+
+    it "should know if using accessible attributes" do
+      @doc_class.accessible_attributes?.should be(true)
+      Doc().accessible_attributes?.should be(false)
+    end
+
+    it "should assign inaccessible attribute through accessor" do
+      @doc.admin = true
+      @doc.admin.should be_truthy
+    end
+
+    it "should ignore inaccessible attribute on #initialize" do
+      doc = @doc_class.new(:name => 'John', :admin => true)
+      doc.admin.should be_falsey
+      doc.name.should == 'John'
+    end
+
+    it "should not ignore inaccessible attributes on #initialize from the database" do
+      doc = @doc_class.new(:name => 'John')
+      doc.admin = true
+      doc.save!
+
+      doc = @doc_class.first(:name => 'John')
+      doc.admin.should be_truthy
+      doc.name.should == 'John'
+    end
+
+    it "should not ignore inaccessible attributes on #reload" do
+      doc = @doc_class.new(:name => 'John')
+      doc.admin = true
+      doc.save!
+
+      doc.reload
+      doc.admin.should be_truthy
+      doc.name.should == 'John'
+    end
+
+    it "should not ignore inaccessible attribute on #update_attribute" do
+      @doc.update_attribute('admin', true)
+      @doc.admin.should be_truthy
+    end
+
+    it "should ignore inaccessible attribute on #update_attributes" do
+      @doc.update_attributes(:name => 'Ren Hoek', :admin => true)
+      @doc.name.should == 'Ren Hoek'
+      @doc.admin.should be_falsey
+    end
+
+    it "should ignore inaccessible attribute on #update_attributes!" do
+      @doc.update_attributes!(:name => 'Stimpson J. Cat', :admin => true)
+      @doc.name.should == 'Stimpson J. Cat'
+      @doc.admin.should be_falsey
+    end
+
+    it "should ignore inaccessible attribute on #attributes=" do
+      @doc.attributes = {:name => 'Ren Hoek', :admin => true}
+      @doc.name.should == 'Ren Hoek'
+      @doc.admin.should be_falsey
+    end
+
+    it "should be indifferent to whether the accessible keys are strings or symbols" do
+      @doc.update_attributes!("name" => 'Stimpson J. Cat', "admin" => true)
+      @doc.name.should == 'Stimpson J. Cat'
+      @doc.admin.should be_falsey
+    end
+
+    it "should accept nil as constructor's argument without raising exception" do
+      lambda { @doc_class.new(nil) }.should_not raise_error
+    end
+
+    it "should ignore all attributes if called with no args" do
+      @doc_class = Doc do
+        key :name
+        attr_accessible
+      end
+
+      @doc_class.new(:name => 'Steve Sloan').name.should be_nil
+    end
+  end
+
+  context "Single collection inherited accessible attributes" do
+    before do
+      class ::GrandParent
+        include MarkMapper::Document
+        attr_accessible :name
+        key :name, String
+        key :site_id, ObjectId
+      end
+      GrandParent.collection.remove
+
+      class ::Child < ::GrandParent
+        attr_accessible :position
+        key :position, Integer
+      end
+
+      class ::GrandChild < ::Child; end
+
+      class ::OtherChild < ::GrandParent
+        attr_accessible :favorite_color
+        key :favorite_color, String
+        key :blog_id, ObjectId
+      end
+    end
+
+    after do
+      Object.send :remove_const, 'GrandParent' if defined?(::GrandParent)
+      Object.send :remove_const, 'Child'       if defined?(::Child)
+      Object.send :remove_const, 'GrandChild'  if defined?(::GrandChild)
+      Object.send :remove_const, 'OtherChild'  if defined?(::OtherChild)
+    end
+
+    it "should share keys down the inheritance trail" do
+      GrandParent.accessible_attributes.should == [:name].to_set
+      Child.accessible_attributes.should == [:name, :position].to_set
+      GrandChild.accessible_attributes.should == [:name, :position].to_set
+      OtherChild.accessible_attributes.should == [:name, :favorite_color].to_set
+    end
+  end
+
+  context "An embedded document with accessible attributes" do
+    before do
+      @doc_class = Doc('Project')
+      @edoc_class = EDoc('Person') do
+        key :name, String
+        key :admin, Boolean, :default => false
+
+        attr_accessible :name
+      end
+      @doc_class.many :people, :class => @edoc_class
+
+      @doc = @doc_class.create(:title => 'MarkMapper')
+      @edoc = @edoc_class.new(:name => 'Steve Sloan')
+      @doc.people << @edoc
+    end
+
+    it "should have accessible attributes class method" do
+      @edoc_class.accessible_attributes.should == [:name].to_set
+    end
+
+    it "should default accessible attributes to nil" do
+      EDoc().accessible_attributes.should be_nil
+    end
+
+    it "should have accessible attributes instance method" do
+      @edoc.accessible_attributes.should equal(@edoc_class.accessible_attributes)
+    end
+
+    it "should assign inaccessible attribute through accessor" do
+      @edoc.admin = true
+      @edoc.admin.should be_truthy
+    end
+
+    it "should ignore inaccessible attribute on #update_attributes" do
+      @edoc.update_attributes(:name => 'Ren Hoek', :admin => true)
+      @edoc.name.should == 'Ren Hoek'
+      @edoc.admin.should be_falsey
+    end
+
+    it "should ignore inaccessible attribute on #update_attributes!" do
+      @edoc.update_attributes!(:name => 'Stimpson J. Cat', :admin => true)
+      @edoc.name.should == 'Stimpson J. Cat'
+      @edoc.admin.should be_falsey
+    end
+  end
+end