guise 0.6.0 → 0.6.1

data/guise.gemspec

@@ -19,22 +19,17 @@ Gem::Specification.new do |gem|
   gem.version       = Guise::VERSION
   gem.license       = 'MIT'
 
-  gem.required_ruby_version = '>= 1.9.3'
+  gem.required_ruby_version = ">= 2.0.0"
 
   gem.add_dependency "activerecord", ">= 3.1", "< 5.0"
   gem.add_dependency "activesupport", ">= 3.1", "< 5.0"
-  gem.add_development_dependency 'rake', '~> 10.1'
+  gem.add_development_dependency "appraisal", ">= 1.0"
+  gem.add_development_dependency "byebug", "~> 5.0"
+  gem.add_development_dependency "codeclimate-test-reporter", "~> 0.3"
+  gem.add_development_dependency "pry", "~> 0.9"
+  gem.add_development_dependency "rake", "~> 10.1"
+  gem.add_development_dependency "redcarpet", "~> 3.2"
   gem.add_development_dependency "rspec", "~> 3.0"
-  gem.add_development_dependency "factory_girl", "~> 4.4"
-  gem.add_development_dependency "shoulda-matchers", "~> 2.5"
-  gem.add_development_dependency "appraisal", '~> 0.5'
-  gem.add_development_dependency 'pry', '~> 0.9'
-  gem.add_development_dependency 'codeclimate-test-reporter', '~> 0.3'
-
-  if RUBY_PLATFORM == 'java'
-    gem.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
-    gem.add_development_dependency 'jdbc-sqlite3'
-  else
-    gem.add_development_dependency 'sqlite3', '~> 1.3'
-  end
+  gem.add_development_dependency "sqlite3", "~> 1.3"
+  gem.add_development_dependency "yard", "~> 0.8"
 end

data/lib/guise.rb

@@ -1,15 +1,39 @@
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/array/extract_options"
 require 'active_support/core_ext/module/attribute_accessors'
+require "active_support/lazy_load_hooks"
 
 require 'guise/version'
+require "guise/errors"
+require "guise/registry"
+require "guise/options"
+require "guise/builders"
+require "guise/scopes"
 require 'guise/callbacks'
-require 'guise/syntax'
-require 'guise/introspection'
+require "guise/introspection"
+require "guise/syntax"
 
 module Guise
   mattr_reader :registry
-  @@registry = HashWithIndifferentAccess.new
+  @@registry = Registry.new
+
+  DEFAULT_ASSOCIATION_NAME = "guises"
+  DEFAULT_ATTRIBUTE_NAME = "value"
+
+  def self.register_source(source_class, *guises)
+    options = Options.new(source_class, *guises)
+    registry[source_class.name] = options
+
+    HasGuisesBuilder.new(options).build!
+  end
+
+  def self.register_association(association_class, source_class_name, association_options)
+    options = registry[source_class_name]
+
+    GuiseForBuilder.new(association_class, options, association_options).build!
+  end
 end
 
-if defined?(ActiveRecord)
-  ActiveRecord::Base.extend(Guise::Syntax)
+ActiveSupport.on_load(:active_record) do
+  extend Guise::Syntax
 end

data/lib/guise/builders.rb

@@ -0,0 +1,129 @@
+require "guise/scopes"
+
+module Guise
+  # @api private
+  class HasGuisesBuilder
+    def initialize(options)
+      @options = options
+    end
+
+    def build!
+      set_guise_options!
+      define_association!
+      define_scopes!
+
+      if @options.association_options != DEFAULT_ASSOCIATION_NAME
+        define_association_aliases!
+      end
+
+      define_introspection_aliases!
+    end
+
+    private
+
+    def set_guise_options!
+      source_class.class_attribute :guise_options, instance_writer: false
+      source_class.guise_options = @options
+    end
+
+    def define_association!
+      source_class.has_many(@options.association_name, @options.association_options)
+    end
+
+    def define_scopes!
+      @options.values.each do |value|
+        method_name = value.underscore
+        scope_name = method_name.pluralize
+
+        source_class.scope scope_name, HasGuisesScope.new(value, @options)
+
+        source_class.class_eval <<-METHOD
+          def #{method_name}?
+            has_guise?('#{value}')
+          end
+        METHOD
+      end
+    end
+
+    def define_association_aliases!
+      source_class.class_eval <<-ASSOCIATION_ALIASES
+        alias_method :guises, :#{association_name}
+        alias_method :guises=, :#{association_name}=
+        alias_method :guise_ids, :#{association_name_singular}_ids
+        alias_method :guise_ids=, :#{association_name_singular}_ids=
+      ASSOCIATION_ALIASES
+    end
+
+    def define_introspection_aliases!
+      source_class.class_eval <<-INTROSPECTION_ALIASES
+        alias_method :has_#{association_name_singular}?, :has_guise?
+        alias_method :has_#{association_name}?, :has_guises?
+        alias_method :has_any_#{association_name}?, :has_any_guises?
+      INTROSPECTION_ALIASES
+    end
+
+    def source_class
+      @options.source_class
+    end
+
+    def association_name
+      @options.association_name
+    end
+
+    def association_name_singular
+      @options.association_name_singular
+    end
+  end
+
+  # @api private
+  class GuiseForBuilder
+    def initialize(association_class, options, association_options)
+      @association_class = association_class
+      @options = options
+      @association_options = association_options.reverse_merge!(@options.default_association_options)
+      @define_validations = !@association_options.delete(:validate)
+    end
+
+    def build!
+      update_guise_options!
+      define_association!
+      define_scopes!
+
+      if define_validations?
+        define_validations!
+      end
+    end
+
+    private
+
+    def define_validations?
+      @define_validations
+    end
+
+    def update_guise_options!
+      @options.association_class = @association_class
+    end
+
+    def define_association!
+      @association_class.belongs_to(@options.source_association_name, @association_options)
+    end
+
+    def define_scopes!
+      @options.values.each do |value|
+        @association_class.scope(
+          value.underscore.pluralize,
+          GuiseForScope.new(value, @options)
+        )
+      end
+    end
+
+    def define_validations!
+      @association_class.validates(
+        @options.attribute,
+        uniqueness: { scope: @options.association_options[:foreign_key] },
+        presence: true,
+        inclusion: { in: @options.values }
+      )
+    end
+  end
+end

data/lib/guise/callbacks.rb

@@ -1,4 +1,5 @@
 module Guise
+  # @api private
   class Callback
     def initialize(guise, attribute)
       @guise = guise
@@ -6,6 +7,7 @@ module Guise
     end
   end
 
+  # @api private
   class SourceCallback < Callback
     def after_initialize(record)
       if record.new_record?
@@ -14,6 +16,7 @@ module Guise
     end
   end
 
+  # @api private
   class AssociationCallback < Callback
     def after_initialize(record)
       record.assign_attributes(@attribute => @guise)

data/lib/guise/errors.rb

@@ -0,0 +1,32 @@
+module Guise
+  class DefinitionNotFound < StandardError
+    def initialize(name)
+      @name = name
+    end
+
+    def message
+      "no guises defined for #{@name.inspect}"
+    end
+  end
+
+  class DuplicateDefinition < StandardError
+    def initialize(name)
+      @name = name
+    end
+
+    def message
+      "guise definition for #{@name.inspect} already exists"
+    end
+  end
+
+  class InvalidGuiseValue < ArgumentError
+    def initialize(guise_value, klass)
+      @guise_value = guise_value
+      @klass = klass
+    end
+
+    def message
+      "`#{guise_value}' is not a defined guise value for #{klass}"
+    end
+  end
+end

data/lib/guise/introspection.rb

@@ -1,31 +1,43 @@
-require 'active_support/concern'
+require "active_support/core_ext/string/inflections"
 
 module Guise
+  # {Introspection} handles checking if a record has one or more `guise` records
+  # associated with it.
   module Introspection
-    extend ActiveSupport::Concern
-
+    # Checks if the record has a `guise` record identified by on the specified
+    # `value`.
+    #
+    # @param [String, Class, Symbol] value `guise` to check
+    # @return [true, false]
     def has_guise?(value)
       value = value.to_s.classify
 
-      unless guise_options[:names].any? { |name| name == value }
+      unless guise_options.values.include?(value)
         raise ArgumentError, "no such guise #{value}"
       end
 
-      guises.any? { |guise| !guise.marked_for_destruction? && guise[guise_options[:attribute]] == value }
+      association(guise_options.association_name).reader.any? do |record|
+        !record.marked_for_destruction? &&
+          record[guise_options.attribute] == value
+      end
     end
 
+    # Checks if the record has any `guise` records with identified by any of
+    # the specified `values`.
+    #
+    # @param [Array<String, Class, Symbol>] value `guise` to check
+    # @return [true, false]
     def has_any_guises?(*values)
       values.any? { |value| has_guise?(value) }
     end
 
+    # Checks if the record has `guise` records for all of the specified
+    # `values`.
+    #
+    # @param [Array<String, Class, Symbol>] value `guise` to check
+    # @return [true, false]
     def has_guises?(*values)
       values.all? { |value| has_guise?(value) }
     end
-
-    private
-
-    def guise_options
-      Guise.registry[self.class.table_name.classify]
-    end
   end
 end

data/lib/guise/options.rb

@@ -0,0 +1,75 @@
+module Guise
+  # @api private
+  class Options
+    attr_reader(
+      :source_class,
+      :values,
+      :association_name,
+      :association_name_singular,
+      :attribute,
+      :association_options,
+      :scopes
+    )
+
+    attr_writer :association_class
+
+    def initialize(source_class, *values)
+      options = values.extract_options!
+
+      if values.empty?
+        raise ArgumentError, "must specify values in `has_guises`"
+      end
+
+      @source_class = source_class
+      @values = values.map(&:to_s).to_set
+      @association_name =
+        options.delete(:association) || DEFAULT_ASSOCIATION_NAME
+      @association_name_singular = @association_name.to_s.singularize
+      @attribute = options.delete(:attribute) || DEFAULT_ATTRIBUTE_NAME
+      @association_options = options.reverse_merge!(default_association_options)
+
+      @scopes = values.inject(HashWithIndifferentAccess.new) do |all, value|
+        all.merge!(value => {})
+      end
+      @scopes.freeze
+    end
+
+    def scope(guise_value, scope_type)
+      value_scopes = @scopes.fetch(guise_value) do
+        raise InvalidGuiseValue.new(guise_value, source_class)
+      end
+
+      value_scopes.fetch(scope_type) do
+        raise ArgumentError, "`#{scope_type}' is not a valid type of scope"
+      end
+    end
+
+    def register_scope(guise_value, scope)
+      value_scopes = @scopes.fetch(guise_value) do
+        raise InvalidGuiseValue.new(guise_value, source_class)
+      end
+
+      if value_scopes.key?(scope.type)
+        raise "`#{scope.type}' scope already defined for #{source_class}"
+      end
+
+      value_scopes[scope.type] = scope
+    end
+
+    def association_class
+      if defined?(@association_class)
+        @association_class
+      else
+        raise "`guise_for` was not called on the association class"
+      end
+    end
+
+    def source_association_name
+      source_class.model_name.singular.to_sym
+    end
+
+    def default_association_options
+      { foreign_key: "#{source_association_name}_id".to_sym }
+    end
+  end
+end

data/lib/guise/registry.rb

@@ -0,0 +1,19 @@
+require "active_support/hash_with_indifferent_access"
+
+module Guise
+  class Registry
+    def initialize
+      @registry = HashWithIndifferentAccess.new
+    end
+
+    def [](name)
+      @registry.fetch(name) do
+        raise DefinitionNotFound.new(name)
+      end
+    end
+
+    def []=(name, definition)
+      @registry[name] = definition
+    end
+  end
+end

data/lib/guise/scopes.rb

@@ -0,0 +1,65 @@
+module Guise
+  # @api private
+  class Scope
+    def initialize(value, options)
+      @value = value
+      @options = options
+
+      @options.register_scope(@value, self)
+    end
+  end
+
+  # @api private
+  class HasGuisesScope < Scope
+    def call
+      relation.create_with(association_name => [association_relation.new])
+    end
+
+    def type
+      :has_guises
+    end
+
+    private
+
+    def relation
+      source_class.
+        select(source_class.arel_table[Arel.star]).
+        joins(association_name).
+        merge(association_relation)
+    end
+
+    def source_class
+      @options.source_class
+    end
+
+    def association_name
+      @options.association_name
+    end
+
+    def association_relation
+      @options.scope(@value, :guise_for).call
+    end
+  end
+
+  # @api private
+  class GuiseOfScope < HasGuisesScope
+    def call
+      relation
+    end
+
+    def type
+      :guise_of
+    end
+  end
+
+  # @api private
+  class GuiseForScope < Scope
+    def call
+      @options.association_class.where(@options.attribute => @value)
+    end
+
+    def type
+      :guise_for
+    end
+  end
+end