active_triples-local_name 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTcyOTBhODdmODAzNWQ5OWJiYjFlOWY3YTA4ZDRmZTBlNDIwYzI3MA==
+  data.tar.gz: !binary |-
+    MTRjNzcwNWQ3NjhkMjQzOWRlZTcyMDVkNTE3ZDFmZDA0NjUzNjM1Nw==
+SHA512:
+  metadata.gz: !binary |-
+    ZTRmYzc4NmEyMjgyYzg2MDE5MWNkMWVlZWJjZjExMzFmMWY4YzBkYTEyZWQ0
+    NTg4MTYyZGNlYmMzZGQyYzJmYjI1MDQ5YWNiZjMzMThiNTU5MmRiMGFmMGIx
+    NTI5YTVhNWQ5NDgwMzgyY2ViZGU2YmVjMWExOGVlOTIwOGVmNTA=
+  data.tar.gz: !binary |-
+    NjBkNDc3NTM4MjMwODlmYTk1M2RlNDJkMmVkMTVkNmJkNjllY2M2YzYzY2Jk
+    ZTUxMWIwMTc2MzkwNmIyYTdhMTVmMTIxODJjMDhlM2I3ZDEwMmViOGVlMGJm
+    MjhiNWI2NjBmYjYwZjU2MGEwZjc1OTM5NWUxMDk2ZTFmNGNjMzQ=

data/.gitignore

@@ -0,0 +1,7 @@
+.bundle/
+log/*.log
+pkg/
+Gemfile.lock
+tmp/*
+.sass-cache
+.idea

data/.travis.yml

@@ -0,0 +1,12 @@
+anguage: ruby
+bundler_args: --without debug
+script: "bundle exec rspec spec"
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1
+  - jruby-19mode
+matrix:
+  allow_failures:
+      - rvm: jruby-19mode

data/AUTHORS

@@ -0,0 +1,2 @@
+* Tom Johnson (thomas.johnson@oregonstate.edu)
+* Trey Terrell

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gemspec
+
+# GETTING FROM GEMFILE UNTIL ActiveTriples master CODE IS RELEASED (>0.4.0), THEN MOVE THIS BACK TO *.gemspec FILE
+# Use active-triple for handling of triple persistence
+gem 'active-triples', :git => 'git@github.com:no-reply/ActiveTriples.git', :branch => 'master'
+

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,12 @@
+##########################################################################
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.md

@@ -0,0 +1,137 @@
+# ActiveTriples::LocalName
+
+
+Provides utilities for working with local names under the [ActiveTriples](https://github.com/ActiveTriples/ActiveTriples) 
+framework.  Includes a default implementation of a local name minter.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_triples-local_name'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install active_triples-local_name
+
+
+## Usage
+
+**Utilities**
+
+* Local Name Minter
+* Others may be added in the future.
+
+
+### Local Name Minter
+
+Common prep code for all examples:
+```ruby
+require 'active_triples'
+require 'active_triples/local_name'
+
+# create an in-memory repository for ad-hoc testing
+ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+
+# create a DummyResource for ad-hoc testing
+# NOTE: local name minter requires resource class to have base_uri configured
+class DummyResourceWithBaseURI < ActiveTriples::Resource
+  configure :base_uri => "http://example.org",
+            :type => RDF::URI("http://example.org/SomeClass"),
+            :repository => :default
+end
+```
+
+#### Example: Using default minter
+```ruby
+# create a new resource with a minted local name using default minter
+localname = ActiveTriples::LocalName::Minter.generate_local_name(
+              DummyResourceWithBaseURI, 10, {:prefix=>'d'})
+# => something like -- "http://example.org/d59beebc5-5238-4aad-bf92-f63fbbd8faaa"
+```
+
+Parameter NOTES:
+* for_class = DummyResourceWithBaseURI - resource class must have base_uri configured
+* max_tries = 10 - If using default minter, it should easily find an available local name in 10 tries.  
+  If your minter algorithm gets lots of clashes with existing URIs and max_tries is set high, you may 
+  run into performance issues.
+* minter_args (optional) = {:prefix=>'d'} - The default minter takes a single hash argument.  You can
+  define minters that take no arguments, multiple arguments, or a multiple item hash argument.
+* minter_block = nil - When minter_block is not passed in, the default minter algorithm, which produces
+  a UUID, will be used.  Best practice is to start local names with an alpha character.  UUIDs generate 
+  with either an alpha or numeric as the first character. Passing in a prefix of 'd' forces the local 
+  name to start with the character 'd'.
+
+
+#### Example: Passing in a block as minter
+
+```ruby
+# create a new resource with a minted local name using passed in block
+localname = ActiveTriples::LocalName::Minter.generate_local_name(
+              DummyResourceWithBaseURI,10,'d') do |prefix|
+                prefix ||= ""
+                local_name = SecureRandom.uuid
+                local_name = prefix + "_blockproc_" + local_name if prefix && prefix.is_a?(String)
+                local_name
+              end
+# => something like -- "http://example.org/d_blockproc_59beebc5-5238-4aad-bf92-f63fbbd8faaa"
+```
+
+
+#### Example: Passing in a method as minter
+```ruby
+# minter method
+def uuid_minter( *options )
+  prefix = options[0][:prefix] if ! options.empty? && options[0].is_a?(Hash) && options[0].key?(:prefix)
+  local_name = SecureRandom.uuid
+  local_name = prefix + "_method_" + local_name if prefix && prefix.is_a?(String)
+  local_name
+end
+
+# create a new resource with a minted local name using a minter method
+localname = ActiveTriples::LocalName::Minter.generate_local_name(
+              DummyResourceWithBaseURI,10,{:prefix=>"d"}) {|args| uuid_minter(args)}
+# => something like -- "http://example.org/d_method_59beebc5-5238-4aad-bf92-f63fbbd8faaa"
+```
+
+#### Example: Override default minter.
+```ruby
+# minter method
+module ActiveTriples
+  module LocalName
+    class Minter
+      def self.default_minter( *options )
+        prefix = options[0][:prefix] if ! options.empty? && options[0].is_a?(Hash) && options[0].key?(:prefix)
+        local_name = SecureRandom.uuid
+        local_name = prefix + "_default_" + local_name if prefix && prefix.is_a?(String)
+        local_name
+      end
+    end
+  end
+end
+
+# create a new resource with a minted local name using override of default minter
+localname = ActiveTriples::LocalName::Minter.generate_local_name(
+              DummyResourceWithBaseURI,10,{:prefix=>"d"})
+# => something like -- "http://example.org/d_default_59beebc5-5238-4aad-bf92-f63fbbd8faaa"
+```
+
+See more examples in spec/active_triples/local_name/minter_spec.rb.
+
+
+## Contributing
+
+Please observe the following guidelines:
+
+ - Do your work in a feature branch based on ```master``` and rebase before submitting a pull request.
+ - Write tests for your contributions.
+ - Document every method you add using YARD annotations. (_Note: Annotations are sparse in the existing codebase, help us fix that!_)
+ - Organize your commits into logical units.
+ - Don't leave trailing whitespace (i.e. run ```git diff --check``` before committing).
+ - Use [well formed](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html) commit messages.
+

data/active_triples-local_name.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_triples/local_name/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_triples-local_name"
+  s.version     = ActiveTriples::LocalName::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["E. Lynette Rayle"]
+  s.homepage    = 'https://github.com/no-reply/active_triples-local_name'
+  s.email       = 'elr37@cornell.edu'
+  s.summary     = %q{Local name minter for ActiveTriples based resources.}
+  s.description = %q{active_triples-local_name provides a standard interface and default implementation for a minter of the local name portion of a URI.}
+  s.license     = "APACHE2"
+  s.required_ruby_version     = '>= 1.9.3'
+
+  # GETTING FROM GEMFILE UNTIL persistent check CODE IS RELEASED
+  # s.add_dependency('active-triples', '~> 0.4')
+
+  s.add_dependency('deprecation', '~> 0.1')
+  s.add_dependency('activesupport', '>= 3.0.0')
+
+  s.add_development_dependency('rdoc')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('guard-rspec')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+end

data/lib/active_triples/local_name.rb

@@ -0,0 +1,28 @@
+# require 'rdf'
+require 'active_triples/local_name/version'
+require 'active_support'
+
+module ActiveTriples
+  module LocalName
+    extend ActiveSupport::Autoload
+    eager_autoload do
+      autoload :Minter
+    end
+
+    def self.class_from_string(class_name, container_class=Kernel)
+      container_class = container_class.name if container_class.is_a? Module
+      container_parts = container_class.split('::')
+      (container_parts + class_name.split('::')).flatten.inject(Kernel) do |mod, class_name|
+        if mod == Kernel
+          Object.const_get(class_name)
+        elsif mod.const_defined? class_name.to_sym
+          mod.const_get(class_name)
+        else
+          container_parts.pop
+          class_from_string(class_name, container_parts.join('::'))
+        end
+      end
+    end
+  end
+end
+

data/lib/active_triples/local_name/minter.rb

@@ -0,0 +1,75 @@
+module ActiveTriples
+  module LocalName
+
+    ##
+    # Provide a standard interface for minting new IDs and validating
+    # the ID is not in use in any known (i.e., registered) repository.
+    class Minter
+
+      ##
+      # Generate a random localname that combined with a class' base_uri does not already exist in
+      # registered triplestores.
+      #
+      # @param [Class] the class inheriting from <tt>ActiveTriples::Reource</tt> whose configuration
+      #   is used to generate the full URI for testing for uniqueness of the generated local name
+      # @param [Integer] the maximum number of attempts to make a unique local name
+      # @yieldparam the arguments to pass to the minter block (optional)
+      # @yield the function to use to mint the local name.  If not specified, the
+      #   +default_minter+ function will be used to generate an UUID.
+      # @yieldreturn [String] the generated local name to be tested for uniqueness
+      #
+      # @return [String] the generated local name
+      #
+      # @raise [ArgumentError] if maximum allowed tries is less than 0
+      # @raise [ArgumentError] if for_class does not inherit from ActiveTriples::Resources
+      # @raise [ArgumentError] if minter_block is not a block (does not respond to call)
+      # @raise [Exception] if for_class does not have base_uri configured
+      # @raise [Exception] if an available local name is not found in the maximum allowed tries.
+      #
+      # @TODO This is inefficient if max_tries is large. Could try
+      #    multi-threading. When using the default_minter included
+      #    in this class, it is unlikely to be a problem and should
+      #    find an ID within the first few attempts.
+      def self.generate_local_name(for_class, max_tries=10, *minter_args, &minter_block)
+        raise ArgumentError, 'Argument max_tries must be >= 1 if passed in' if     max_tries    <= 0
+
+        raise ArgumentError, 'Argument for_class must inherit from ActiveTriples::Resource' unless for_class < ActiveTriples::Resource
+        raise 'Requires base_uri to be defined in for_class.' unless for_class.base_uri
+
+        raise ArgumentError, 'Invalid minter_block.' if minter_block && !minter_block.respond_to?(:call)
+        minter_block = proc { |args| default_minter(args) } unless minter_block
+
+        found   = true
+        test_id = nil
+        (1).upto(max_tries) do
+          test_id = minter_block.call( *minter_args )
+          found = for_class.id_persisted?(test_id)
+          break unless found
+        end
+        raise 'Available ID not found.  Exceeded maximum tries.' if found
+        test_id
+      end
+
+      ##
+      # Default minter used by generate_id.
+      #
+      # @param [Hash] options the options to use while generating the local name
+      # @option options [String] :prefix the prefix to put before the generated local name (optional)
+      #
+      # @note Because <tt>:prefix</tt> is optional, errors in type for <tt>:prefix</tt> are ignored.  Any additional
+      #   parameters beyond <tt>:prefix</tt> are also ignored.
+      #
+      # @note Best practice is to begin localnames with an alpha character.  UUIDs can generate with an alpha or
+      #   numeric as the first character.  Pass in an alpha character as <tt>:prefix</tt> to enforce this best
+      #   practice.
+      #
+      # @return [String] a uuid
+      def self.default_minter( *options )
+        prefix = options[0][:prefix] if ! options.empty? && options[0].is_a?(Hash) && options[0].key?(:prefix)
+        local_name = SecureRandom.uuid
+        local_name = prefix + local_name if prefix && prefix.is_a?(String)
+        local_name
+      end
+    end
+  end
+end

data/lib/active_triples/local_name/version.rb

@@ -0,0 +1,5 @@
+module ActiveTriples
+  module LocalName
+    VERSION = "0.1.0"
+  end
+end

data/spec/active_triples/local_name/minter_spec.rb

@@ -0,0 +1,336 @@
+require 'spec_helper'
+
+describe ActiveTriples::LocalName::Minter do
+
+  describe "#generate_local_name" do
+    before (:all) do
+      @timeHashMinter_lambda = lambda do |digit_count|
+        rnd_id = 0
+        rnd_id = Time.now.hash until rnd_id != 0
+        rnd_id *= -1 if rnd_id < 0
+        rnd_id /= 10 until rnd_id < (10**digit_count)
+        "lambda_#{rnd_id}"
+      end
+
+      @timeHashMinter_proc = proc do |digit_count|
+        rnd_id = 0
+        rnd_id = Time.now.hash until rnd_id != 0
+        rnd_id *= -1 if rnd_id < 0
+        rnd_id /= 10 until rnd_id < (10**digit_count)
+        "proc_#{rnd_id}"
+      end
+
+      @timeHashMinter2_proc = proc do |digit_count,prefix|
+        rnd_id = 0
+        rnd_id = Time.now.hash until rnd_id != 0
+        rnd_id *= -1 if rnd_id < 0
+        rnd_id /= 10 until rnd_id < (10**digit_count)
+        "#{prefix}_#{rnd_id}"
+      end
+
+      # See also timeHashMinter_method defined in DummyResourceWithBaseURI class below.
+    end
+
+    subject {DummyResourceWithBaseURI.new('1')}
+
+    before do
+      class DummyResource < ActiveTriples::Resource
+        configure :type => RDF::URI('http://example.org/SomeClass')
+        property :title, :predicate => RDF::DC.title
+      end
+      class DummyResourceWithBaseURI < ActiveTriples::Resource
+        configure :base_uri => "http://example.org",
+                  :type => RDF::URI("http://example.org/SomeClass"),
+                  :repository => :default
+
+        def self.timeHashMinter_method( *args )
+          digit_count = args.size > 0 ? args[0] : 10
+          rnd_id = 0
+          rnd_id = Time.now.hash until rnd_id != 0
+          rnd_id *= -1 if rnd_id < 0
+          rnd_id /= 10 until rnd_id < (10**digit_count)
+          "method_#{rnd_id}"
+        end
+
+        def self.timeHashMinter2_method( *args )
+          digit_count = args && args.size > 0 ? args[0] : 10
+          prefix =  args && args.size > 1 ? args[1] : ""
+          rnd_id = 0
+          rnd_id = Time.now.hash until rnd_id != 0
+          rnd_id *= -1 if rnd_id < 0
+          rnd_id /= 10 until rnd_id < (10**digit_count)
+          "#{prefix}_#{rnd_id}"
+        end
+
+        def self.timeHashMinter3_method( *args )
+          digit_count = (args && args.size > 0 && args[0]) ? args[0][:digit_count] : 10
+          prefix =  args && args.size > 0 && args[0] ? args[0][:prefix] : ""
+          rnd_id = 0
+          rnd_id = Time.now.hash until rnd_id != 0
+          rnd_id *= -1 if rnd_id < 0
+          rnd_id /= 10 until rnd_id < (10**digit_count)
+          localname = "#{prefix}_#{rnd_id}"
+          localname
+        end
+      end
+      ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+    end
+    after do
+      Object.send(:remove_const, "DummyResourceWithBaseURI") if Object
+      Object.send(:remove_const, "DummyResource") if Object
+      ActiveTriples::Repositories.clear_repositories!
+    end
+
+    context "when class doesn't have base_uri defined" do
+      it "should raise an Exception" do
+        expect{ ActiveTriples::LocalName::Minter.generate_local_name(DummyResource) }.to raise_error(RuntimeError, 'Requires base_uri to be defined in for_class.')
+      end
+    end
+
+    context "when all IDs available" do
+      context "and no minter function is passed in" do
+        it "should generate an ID using default minter function" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI)
+          expect(id).to be_kind_of String
+          expect(id.length).to be 36
+          id.should match /[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+
+      context "and minter function is passed as ad-hoc proc" do
+        it "should generate an ID with passed in minter function block" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,1) do |digit_count|
+            rnd_id = 0
+            rnd_id = Time.now.hash until rnd_id != 0
+            rnd_id *= -1 if rnd_id < 0
+            rnd_id /= 10 until rnd_id < (10**digit_count)
+            rnd_id
+          end
+          expect(id).to be_between(1,9)
+        end
+      end
+
+      context "and minter function is pre-defined proc that takes 1 parameter" do
+        context "and minter function is passed as proc in block with hardcoded parameter" do
+          it "should generate an ID with passed in proc in block" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI) {
+              @timeHashMinter_proc.call(1) }
+            expect(id[0..4]).to eq "proc_"
+            expect(id[5..id.length].to_i).to be_between(1,9)
+          end
+        end
+
+        context "and minter function is passed as proc in block with parameter passed in minterargs" do
+          it "should generate an ID with passed in proc in block" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,1) {
+              |digit_count| @timeHashMinter_proc.call(digit_count) }
+            expect(id[0..4]).to eq "proc_"
+            expect(id[5..id.length].to_i).to be_between(1,9)
+          end
+        end
+
+        context "and minter function is passed address to proc with parameter passed in minterargs" do
+          it "should generate an ID with passed in proc" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,1,
+                                                                      &@timeHashMinter_proc)
+            expect(id[0..4]).to eq "proc_"
+            expect(id[5..id.length].to_i).to be_between(1,9)
+          end
+        end
+      end
+
+      context "and minter function is pre-defined proc that takes 2 parameter" do
+        context "and minter function is passed as proc in block with hardcoded parameter" do
+          it "should generate an ID with passed in proc in block" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI) {
+              @timeHashMinter2_proc.call(1,'foo') }
+            expect(id[0..3]).to eq "foo_"
+            expect(id[4..id.length].to_i).to be_between(1,9)
+          end
+        end
+
+        context "and minter function is passed as proc in block with parameter passed in minterargs" do
+          it "should generate an ID with passed in proc in block" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,1,'foo') {
+                |digit_count,prefix| @timeHashMinter2_proc.call(digit_count,prefix) }
+            expect(id[0..3]).to eq "foo_"
+            expect(id[4..id.length].to_i).to be_between(1,9)
+          end
+        end
+
+        context "and minter function is passed address to proc with parameters passed in minterargs" do
+          it "should generate an ID with passed in proc" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,1,"foo",
+                                                                      &@timeHashMinter2_proc)
+            expect(id[0..3]).to eq "foo_"
+            expect(id[4..id.length].to_i).to be_between(1,9)
+          end
+        end
+      end
+
+
+      context "and minter function is method that takes 1 parameter" do
+        context "and parameter is hardcoded in block" do
+          it "should generate an ID with passed in method" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI) {
+              DummyResourceWithBaseURI.timeHashMinter_method (1) }
+            expect(id[0..6]).to eq "method_"
+            expect(id[7..id.length].to_i).to be_between(1,9)
+          end
+        end
+
+        context "and parameter is passed as minterargs" do
+          it "should generate an ID with passed in method" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,1) {
+                |digit_count| DummyResourceWithBaseURI.timeHashMinter_method(digit_count) }
+            expect(id[0..6]).to eq "method_"
+            expect(id[7..id.length].to_i).to be_between(1,9)
+          end
+        end
+      end
+
+
+      context "and minter function is method that takes 2 parameters" do
+        context "and parameters are hardcoded in block" do
+          it "should generate an ID with passed in method" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI) {
+              DummyResourceWithBaseURI.timeHashMinter2_method(1,"foo") }
+            expect(id[0..3]).to eq "foo_"
+            expect(id[4..id.length].to_i).to be_between(1,9)
+          end
+        end
+
+        context "and parameters are passed as minterargs" do
+          it "should generate an ID with passed in method" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,1,"foo") {
+                |digit_count,prefix| DummyResourceWithBaseURI.timeHashMinter2_method(digit_count,prefix) }
+            expect(id[0..3]).to eq "foo_"
+            expect(id[4..id.length].to_i).to be_between(1,9)
+          end
+        end
+      end
+
+
+      context "and minter function is method that takes 1 hash parameter" do
+        context "and parameter is hardcoded in block" do
+          it "should generate an ID with passed in method" do
+            id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI) {
+              DummyResourceWithBaseURI.timeHashMinter3_method({:digit_count=>1,:prefix=>"foo"}) }
+            expect(id[0..3]).to eq "foo_"
+            expect(id[4..id.length].to_i).to be_between(1,9)
+          end
+        end
+      end
+
+      context "and parameter is passed as minterargs" do
+        it "should generate an ID with passed in method" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,{:digit_count=>1,:prefix=>"foo"}) {
+              |hash_args| DummyResourceWithBaseURI.timeHashMinter3_method(hash_args) }
+          expect(id[0..3]).to eq "foo_"
+          expect(id[4..id.length].to_i).to be_between(1,9)
+        end
+      end
+
+      context "and no parameters are passed in" do
+        it "should generate an ID with passed in method using defaults when no params passed" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10) {
+              |hash_args| DummyResourceWithBaseURI.timeHashMinter3_method(hash_args) }
+          expect(id[0]).to eq "_"
+          expect(id[1..id.length].to_i).to be_between(1000000000,9999999999)
+        end
+      end
+
+      context "but block defines method with no parameters" do
+        it "should generate an ID with passed in method using defaults when no params passed" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10) {
+              DummyResourceWithBaseURI.timeHashMinter3_method }
+          expect(id[0]).to eq "_"
+          expect(id[1..id.length].to_i).to be_between(1000000000,9999999999)
+        end
+      end
+    end
+    context "when some IDs available" do
+      before do
+        DummyResourceWithBaseURI.new('proc_3').persist!
+        DummyResourceWithBaseURI.new('proc_4').persist!
+        DummyResourceWithBaseURI.new('proc_8').persist!
+      end
+      after do
+        DummyResourceWithBaseURI.new('proc_3').destroy!
+        DummyResourceWithBaseURI.new('proc_4').destroy!
+        DummyResourceWithBaseURI.new('proc_8').destroy!
+      end
+
+      it "should generate an ID not already in use" do
+        id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI) { @timeHashMinter_proc.call(1) }
+        expect(id[0..4]).to eq "proc_"
+        expect(id[5..id.length].to_i).to be_between(1,9)
+        expect(id).not_to eq 'proc_3'
+        expect(id).not_to eq 'proc_4'
+        expect(id).not_to eq 'proc_8'
+      end
+    end
+
+    context "when no IDs available" do
+      before do
+        1.upto(9) { |id| DummyResourceWithBaseURI.new("proc_#{id}").persist! }
+      end
+      after do
+        1.upto(9) { |id| DummyResourceWithBaseURI.new("proc_#{id}").destroy! }
+      end
+
+      it "should raise an Exception" do
+        expect{ ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI) { @timeHashMinter_proc.call(1) } }.
+            to raise_error(RuntimeError, "Available ID not found.  Exceeded maximum tries.")
+      end
+    end
+
+    context "when passing prefix to default minter function" do
+      context "and prefix is string" do
+        it "should generate a prefixed ID" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,{:prefix=>"s"})
+          expect(id).to be_kind_of String
+          expect(id.length).to be 37
+          id.should match /s[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+
+      context "and prefix is integer" do
+        it "should generate ID ignoring prefix" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,1)
+          expect(id).to be_kind_of String
+          expect(id.length).to be 36
+          id.should match /[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+
+      context "and prefix is float" do
+        it "should generate ID ignoring prefix" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,{:prefix=>1.5})
+          expect(id).to be_kind_of String
+          expect(id.length).to be 36
+          id.should match /[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+
+      context "and prefix is hash" do
+        it "should generate ID ignoring prefix" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,{:prefix=>{"a"=>"b"}})
+          expect(id).to be_kind_of String
+          expect(id.length).to be 36
+          id.should match /[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+
+      context "and prefix is array" do
+        it "should generate ID ignoring prefix" do
+          id = ActiveTriples::LocalName::Minter.generate_local_name(DummyResourceWithBaseURI,10,{:prefix=>[1,2,3]})
+          expect(id).to be_kind_of String
+          expect(id.length).to be 36
+          id.should match /[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'active_triples/local_name'
+require 'active_triples'
+
+
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+RSpec.configure do |config|
+  config.color = true
+  config.tty = true
+  
+  # Uncomment the following line to get errors and backtrace for deprecation warnings
+  # config.raise_errors_for_deprecations!
+
+  # Use the specified formatter
+  config.formatter = :progress
+end

data/spec/support/active_model_lint.rb

@@ -0,0 +1,81 @@
+shared_examples_for "an ActiveModel" do
+  subject { described_class.new }
+
+  describe '#to_key' do
+    it 'should respond' do
+      expect(subject).to respond_to :to_key
+    end
+
+    it 'should return nil when #persisted? is false ' do
+      def subject.persisted?() false end
+      expect(subject.to_key).to eq nil
+    end
+  end
+
+  describe '#to_param' do
+    it 'should respond' do
+      expect(subject).to respond_to :to_param
+    end
+
+    it 'should return nil when #persisted? is false ' do
+      def subject.persisted?() false end
+      expect(subject.to_param).to eq nil
+    end
+  end
+
+  describe '#model_name' do
+    let(:model_name) { subject.class.model_name }
+
+    it 'should have a model name' do
+      expect(model_name).to respond_to :to_str
+    end
+
+    it 'should have a human name' do
+      expect(model_name.human).to respond_to :to_str
+    end
+
+    it 'should have a singular name' do
+      expect(model_name.singular).to respond_to :to_str
+    end
+
+    it 'should have a plural name' do
+      expect(model_name.plural).to respond_to :to_str
+    end
+  end
+
+  describe '#to_partial_path' do
+    it 'should return a string' do
+      expect(subject.to_partial_path).to be_a String
+    end
+  end
+
+  describe '#persisted?' do
+    it 'should return a boolean' do
+      expect(match_boolean(subject.persisted?)).to be true
+    end
+  end
+
+  describe '#valid?' do
+    it 'should return a boolean' do
+      expect(match_boolean(subject.valid?)).to be true
+    end
+  end
+
+  describe '#new_record' do
+    it 'should return a boolean' do
+      expect(match_boolean(subject.new_record?)).to be true
+    end
+  end
+
+  describe '#destroyed?' do
+    it 'should return a boolean' do
+      expect(match_boolean(subject.destroyed?)).to be true
+    end
+  end
+
+  private 
+  
+    def match_boolean(result)
+      result == true || result == false
+    end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: active_triples-local_name
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- E. Lynette Rayle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: deprecation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: active_triples-local_name provides a standard interface and default implementation
+  for a minter of the local name portion of a URI.
+email: elr37@cornell.edu
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- .gitignore
+- .travis.yml
+- AUTHORS
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- active_triples-local_name.gemspec
+- lib/active_triples/local_name.rb
+- lib/active_triples/local_name/minter.rb
+- lib/active_triples/local_name/version.rb
+- spec/active_triples/local_name/minter_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_model_lint.rb
+homepage: https://github.com/no-reply/active_triples-local_name
+licenses:
+- APACHE2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+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: Local name minter for ActiveTriples based resources.
+test_files: []