kete_trackable_items 0.0.1

data/lib/kete_trackable_items/extensions/models/basket.rb

@@ -0,0 +1,4 @@
+# extensions to the kete basket model
+Basket.class_eval do
+  has_many :repositories, :dependent => :destroy
+end

data/lib/kete_trackable_items/extensions/models/topic.rb

@@ -0,0 +1,6 @@
+# extensions to the kete topic model
+Topic.class_eval do
+  # adding trackable item functionality
+  include KeteTrackableItems::TrackableItem
+  set_up_as_trackable_item :described_as => :reference_title_date_range
+end

data/lib/kete_trackable_items/matching_trackable_items_controller_helpers.rb

@@ -0,0 +1,42 @@
+module KeteTrackableItems
+  module MatchingTrackableItemsControllerHelpers
+    def set_matching_trackable_items
+      # do we have a search for trackable_items to add?
+      if params[:trackable_type_param_key].present?
+        # compose our find based on input and Kete.trackable_item_scopes
+        type_key_plural = params[:trackable_type_param_key]
+
+        type_key = type_key_plural.singularize
+        class_name = type_key.camelize
+        klass = class_name.constantize
+
+        always_scopes = Kete.trackable_item_scopes[type_key]['search_scopes']['always_within_scopes'].keys
+
+        # a trackable_item has to be allocated a shelf before it can be added to a tracking_list
+        always_scopes << 'with_state_on_shelf' if params[:controller] == 'tracking_lists'
+        
+        scope_value_pairs = params[type_key_plural].select { |k, v| v.present? }
+        
+        scope_value_pairs << ['in_basket', @current_basket.id] unless @current_basket == @site_basket
+
+        relevent_scopes = always_scopes + scope_value_pairs
+
+        @matching_trackable_items = relevent_scopes.inject(klass) do |model_class, relevent_scope|
+          if relevent_scope.is_a?(Array)
+            model_class.send(relevent_scope.first, relevent_scope.last)
+          else
+            model_class.send(relevent_scope)
+          end
+        end
+      end
+    end
+
+    def build_items_for_matching_trackable_items_for(target, collection_name)
+      if @matching_trackable_items.present?
+        @matching_trackable_items.each do |trackable_item|
+          target.send(collection_name).build(:trackable_item => trackable_item)
+        end
+      end
+    end
+  end
+end

data/lib/kete_trackable_items/trackable_item.rb

@@ -0,0 +1,80 @@
+require "active_record"
+
+module KeteTrackableItems
+  module TrackableItem
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def set_up_as_trackable_item(*args)
+        options = args.last.is_a?(Hash) ? args.pop : Hash.new
+
+        # don't allow multiple calls
+        return if self.included_modules.include?(KeteTrackableItems::TrackableItem::InstanceMethods)
+
+        send :include, KeteTrackableItems::TrackableItem::InstanceMethods
+
+        # associations to support allocating a trackable_item to a shelf_location or shelf_locations
+        send :has_many, :trackable_item_shelf_locations, :as => :trackable_item, :dependent => :delete_all
+        send :has_many, :shelf_locations, :through => :trackable_item_shelf_locations, :conditions => "trackable_item_shelf_locations.workflow_state = 'active'"
+        # associations to support adding a trackable_item to a tracking_list
+        send :has_many, :tracked_items, :as => :trackable_item, :dependent => :delete_all
+        send :has_many, :tracking_lists, :through => :tracked_items
+
+        # when a trackable_item is in 'on_loan' state, which on_loan_organization is it on loan to?
+        send :belongs_to, :on_loan_organization
+
+        self.non_versioned_columns << "on_loan_organization_id"
+
+        cattr_accessor :described_as_in_tracking_list
+        self.described_as_in_tracking_list = options[:described_as] || :title
+
+        # set up our states and events through workflow gem
+        send :include, KeteTrackableItems::WorkflowUtilities
+    
+        class_eval do
+          shared_code_as_string = shared_tracking_workflow_specs_as_string
+
+          specification = Proc.new {
+            state :unallocated do
+              event :allocate, :transitions_to => :on_shelf
+            end
+
+            eval(shared_code_as_string)
+
+            state :to_be_refiled do
+              event :refile, :transitions_to => :on_shelf
+            end
+          }
+
+          workflow(&specification)
+
+          set_up_workflow_named_scopes.call
+        end
+
+        self.non_versioned_columns << "workflow_state"
+      end
+    end
+
+    module InstanceMethods
+      # could be called is_allocated_to_shelf ?
+      def has_shelf_locations?
+        shelf_locations.size > 0
+      end
+
+      def description_for_tracked_item
+        send(self.class.described_as_in_tracking_list)
+      end
+
+      # add workflow triggered methods that run when corresponding event is triggered as necessary
+      def new_allocation
+        allocate!
+      end
+
+      def mapping_deactivated_or_destroyed
+        unassign_location! if on_shelf? && !has_shelf_locations?
+      end
+    end
+  end
+end

data/lib/kete_trackable_items/version.rb

@@ -0,0 +1,3 @@
+module KeteTrackableItems
+  VERSION = "0.0.1"
+end

data/lib/kete_trackable_items/workflow_utilities.rb

@@ -0,0 +1,91 @@
+module KeteTrackableItems
+  module WorkflowUtilities
+    def self.included(base)
+      base.send :include, Workflow
+      base.extend(ClassMethods)
+      base.send :include, InstanceMethods
+    end
+    
+    # mostly grabbed from trollied, would be nice if split into shared lib
+    module ClassMethods
+      # returns a Hash where keys are event name and values are event object
+      def workflow_events
+        events = workflow_spec.states.values.collect &:events
+
+        # skip blank values
+        events = events.select { |e| e.present? }
+
+        # flatten
+        events_hash = Hash.new
+        events.each do |v|
+          v.each do |key,value|
+            events_hash[key] = value
+          end
+        end
+
+        events_hash
+      end
+
+      def workflow_event_names
+        workflow_events.keys
+      end
+
+      # kete_trackable_items specific stuff starts
+      def shared_tracking_workflow_specs_as_string
+        '
+          state :on_shelf do
+            event :unassign_location, :transitions_to => :unallocated
+            event :display, :transitions_to => :displayed
+            event :hold_out, :transitions_to => :held_out
+            event :loan, :transitions_to => :on_loan_to_organization
+          end
+
+          state :displayed do
+            event :hold_out, :transitions_to => :held_out
+            event :loan, :transitions_to => :on_loan_to_organization
+            event :queue_for_refiling, :transitions_to => :to_be_refiled
+          end
+
+          state :held_out do
+            event :loan, :transitions_to => :on_loan_to_organization
+            event :queue_for_refiling, :transitions_to => :to_be_refiled
+          end
+
+          state :on_loan_to_organization do
+            event :display, :transitions_to => :displayed
+            event :hold_out, :transitions_to => :held_out
+            event :queue_for_refiling, :transitions_to => :to_be_refiled
+          end
+        '
+      end
+
+      def set_up_workflow_named_scopes
+        Proc.new {
+          # create a named_scope for each of our declared states
+          workflow_spec.state_names.each do |name|
+            scope_name = "with_state_#{name}".to_sym
+            named_scope scope_name, :conditions => { :workflow_state => name.to_s }, :order => 'updated_at DESC'
+          end
+
+          # workflow_in(state_name)
+          named_scope :workflow_in, lambda { |*args|
+            options = args.last.is_a?(Hash) ? args.pop : Hash.new
+            state = args.is_a?(Array) ? args.first : args
+            
+            if state == 'all'
+              options
+            else
+              { :conditions => { :workflow_state => state.to_s }.merge(options) }
+            end
+          }
+        }
+      end
+    end
+
+    module InstanceMethods
+      def current_state_humanized
+        current_state.name.to_s.humanize
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,68 @@
+ActionController::Base.send(:include, KeteTrackableItems::ControllerHelpers)
+ActionController::Base.send(:helper, TrackableItemsHelper)
+
+config.to_prepare do
+  # load our locales
+  I18n.load_path += Dir[File.join(File.dirname(__FILE__), '../config/locales/*.{rb,yml}')]
+
+  # override some controllers and helpers to be kete gets trollied aware
+  exts = File.join(File.dirname(__FILE__), '../lib/kete_trackable_items/extensions/{controllers,helpers}/*')
+  # use Kernel.load here so that changes to the extensions are reloaded on each request in development
+  Dir[exts].each { |ext_path| Kernel.load(ext_path) }
+
+  # models we extend
+  Dir[File.join(File.dirname(__FILE__), '../lib/kete_trackable_items/extensions/models/*')].each do |ext_path|
+    key = File.basename(ext_path, '.rb').to_sym
+    Kete.add_code_to_extensions_for(key, Proc.new { Kernel.load(ext_path) })
+  end
+
+  # this is for site specific defined search scopes
+  # i.e. you can place your own Kete site's extended fields set up dependent search definitions
+  # in a config and have them available to kete_trackable_items code
+  Kete.define_reader_method_as('trackable_item_scopes',
+                               YAML.load(IO.read(File.join(Rails.root, 'config/trackable_item_scopes.yml'))))
+  
+  Kete.trackable_item_scopes.each do |key, options|
+    klass = key.camelize.constantize
+    key = key.to_sym
+
+    if options['prerequisite_extensions'].present?
+      options['prerequisite_extensions'].each do |code|
+        extension = Proc.new {
+          klass.class_eval do
+            eval(code)
+          end
+        }
+
+        Kete.add_code_to_extensions_for(key, extension)
+      end
+    end
+
+    if options['search_scopes'].present?
+      if options['search_scopes']['always_within_scopes'].present?
+        options['search_scopes']['always_within_scopes'].each do |scope_key, scope_code|
+          extension = Proc.new {
+            klass.class_eval do
+              named_scope(scope_key.to_sym, eval(scope_code))
+            end
+          }
+
+          Kete.add_code_to_extensions_for(key, extension)
+        end
+      end
+
+      if options['search_scopes']['text_searches'].present?
+        options['search_scopes']['text_searches'].each do |search_specs|
+          search_specs.each do |scope_key, scope_code|
+            extension = Proc.new {
+              klass.class_eval do
+                named_scope(scope_key.to_sym, eval(scope_code))
+              end
+            }
+            Kete.add_code_to_extensions_for(key, extension)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification 
+name: kete_trackable_items
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Walter McGinnis
+- Noel Gomez
+- Chris Toynbee
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-31 00:00:00 +12:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: A Kete application add-on that allows for tracking the location of an item in a physical archive that corresponds to the item in the Kete application.
+email: 
+- ctoynbee@gmail.com
+- walter@katipo.co.nz
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .document
+- .gitignore
+- .specification
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- app/controllers/repositories_controller.rb
+- app/controllers/shelf_locations_controller.rb
+- app/controllers/trackable_item_shelf_locations_controller.rb
+- app/controllers/tracked_items_controller.rb
+- app/controllers/tracking_lists_controller.rb
+- app/helpers/trackable_item_shelf_locations_helper.rb
+- app/helpers/trackable_items_helper.rb
+- app/models/on_loan_organization.rb
+- app/models/repository.rb
+- app/models/shelf_location.rb
+- app/models/trackable_item_shelf_location.rb
+- app/models/tracked_item.rb
+- app/models/tracking_list.rb
+- app/views/repositories/_form.html.erb
+- app/views/repositories/edit.html.erb
+- app/views/repositories/index.html.erb
+- app/views/repositories/new.html.erb
+- app/views/repositories/show.html.erb
+- app/views/shelf_locations/_event_button.html.erb
+- app/views/shelf_locations/_form.html.erb
+- app/views/shelf_locations/_shelf_location.html.erb
+- app/views/shelf_locations/_shelf_locations.html.erb
+- app/views/shelf_locations/_trackable_item.html.erb
+- app/views/shelf_locations/edit.html.erb
+- app/views/shelf_locations/index.html.erb
+- app/views/shelf_locations/new.html.erb
+- app/views/shelf_locations/show.html.erb
+- app/views/trackable_item_shelf_locations/new.html.erb
+- app/views/tracked_items/_tracked_item.html.erb
+- app/views/tracking_lists/_event_button.html.erb
+- app/views/tracking_lists/_form.html.erb
+- app/views/tracking_lists/_trackable_item_search_form.html.erb
+- app/views/tracking_lists/_tracking_list.html.erb
+- app/views/tracking_lists/_tracking_lists.html.erb
+- app/views/tracking_lists/edit.html.erb
+- app/views/tracking_lists/index.html.erb
+- app/views/tracking_lists/show.html.erb
+- app/views/tracking_lists/show.xls.builder
+- config/locales/en.yml
+- config/routes.rb
+- generators/kete_trackable_items_migrations/USAGE
+- generators/kete_trackable_items_migrations/kete_trackable_items_migrations_generator.rb
+- generators/kete_trackable_items_migrations/templates/add_trackable_item_columns_to_topics.rb
+- generators/kete_trackable_items_migrations/templates/create_on_loan_organizations.rb
+- generators/kete_trackable_items_migrations/templates/create_repositories.rb
+- generators/kete_trackable_items_migrations/templates/create_shelf_locations.rb
+- generators/kete_trackable_items_migrations/templates/create_trackable_item_shelf_locations.rb
+- generators/kete_trackable_items_migrations/templates/create_tracked_items.rb
+- generators/kete_trackable_items_migrations/templates/create_tracking_lists.rb
+- kete_trackable_items.gemspec
+- lib/kete_trackable_items.rb
+- lib/kete_trackable_items/controller_helpers.rb
+- lib/kete_trackable_items/extensions/helpers/application_helper.rb
+- lib/kete_trackable_items/extensions/models/basket.rb
+- lib/kete_trackable_items/extensions/models/topic.rb
+- lib/kete_trackable_items/matching_trackable_items_controller_helpers.rb
+- lib/kete_trackable_items/trackable_item.rb
+- lib/kete_trackable_items/version.rb
+- lib/kete_trackable_items/workflow_utilities.rb
+- rails/init.rb
+has_rdoc: true
+homepage: https://github.com/kete/kete_trackable_items
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: kete_trackable_items
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Rails engine gem that works in conjunction with kete_gets_trollied to track where an item (with a corresponding physical archive) is physically located.
+test_files: []
+