emittance 0.0.2 → 0.0.3

data/lib/emittance/helpers/constant_helpers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Emittance
+  module Helpers
+    ##
+    # Some helpers for fetching, setting, and manipulating constants.
+    #
+    module ConstantHelpers
+      # Since +Object.const_set+ does not support namespaced constant names, use this to set the constant to the
+      # correct namespace.
+      #
+      # Example:
+      #
+      #   my_const_name = 'String::Foo'
+      #   Object.const_set my_const_name, 'bar'
+      #   # => NameError: wrong constant name String::Foo
+      #
+      #   set_namespaced_constant_by_name my_const_name, 'bar'
+      #   String::Foo
+      #   # => 'bar'
+      #
+      # @param const_name [String] a valid namespaced constant name
+      # @param obj the value you wish to set that constant to
+      def set_namespaced_constant_by_name(const_name, obj)
+        names = const_name.split('::')
+        names.shift if names.size > 1 && names.first.empty?
+
+        namespace = names.size == 1 ? Object : Object.const_get(names[0...-1].join('::'))
+        namespace.const_set names.last, obj
+      end
+    end
+  end
+end

data/lib/emittance/helpers/string_helpers.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Emittance
+  module Helpers
+    ##
+    # Some helper methods to mix in for the purposes of manipulating strings.
+    #
+    module StringHelpers
+      # Snake case the string, like Rails' +String#underscore+ method. As such, strings that look like namespaced
+      # constants will have the namespace resolver operators replaced with +/+ characters, rather than underscores.
+      # For example: +'Foo::BarBaz'+ becomes +'foo/bar_baz'+.
+      #
+      # @param str [String] the string you wish to convert
+      # @return [String] a new string that is the snake-cased version of the old string
+      def snake_case(str)
+        str.gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end
+
+      # Camel case the string, like Rails' +String#classify+ method. This essentially works like the inverse of
+      # +snake_case+, so +'foo/bar_baz'+ becomes +'Foo::BarBaz'+. There is one one notable exception:
+      #
+      #   camel_case(snake_case('APIFoo'))
+      #   # => 'ApiFoo'
+      #
+      # As such, be mindful when naming your classes.
+      #
+      # @param str [String] the string you wish to convert
+      # @return [String] a new string converted to camel case.
+      def camel_case(str)
+        str = str.sub(/^[a-z\d]*/) { $&.capitalize }
+        str = str.gsub(%r{(?:_|(\/))([a-z\d]*)}) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
+        str.gsub(%r{\/}, '::')
+      end
+
+      # Strip all characters that can't go into a constant name.
+      #
+      # @param str [String] the string from which you want to remove punctuation
+      # @return [String] a new string with punctuation stripped
+      def clean_up_punctuation(str)
+        str.gsub(%r{[^A-Za-z\d\_\:\/]}, '')
+      end
+    end
+  end
+end

data/lib/emittance/registration.rb

@@ -3,10 +3,10 @@
 module Emittance
   # @private
   class Registration
-    attr_reader :identifier
+    attr_reader :event_klass
 
-    def initialize(identifier, &callback)
-      @identifier = identifier
+    def initialize(event_klass, &callback)
+      @event_klass = event_klass
       @callback = callback
     end
 

data/lib/emittance/version.rb

@@ -1,5 +1,5 @@
-# froze_string_literal: true
+# frozen_string_literal: true
 
 module Emittance
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/emittance/watcher.rb

@@ -1,7 +1,19 @@
 # frozen_string_literal: true
 
 module Emittance
+  ##
+  # Can watch for events that propagate through the system.
+  #
   module Watcher
+    # Watch for an event, identified by its class' identifier. If a callback method is provided, then it will call that
+    # method on the caller of +watch+ when the event happens. Otherwise, it will run the callback block.
+    #
+    # @param identifier [Symbol] the event's identifier
+    # @param callback_method [Symbol] one option for adding a callback--the method on the object to call when the
+    #   event fires
+    # @param callback [Block] the other option for adding a callback--the block you wish to be executed when the event
+    #   fires
+    # @return [Proc] the block that will run when the event fires
     def watch(identifier, callback_method = nil, &callback)
       if callback_method
         Emittance::Dispatcher.register_method_call identifier, self, callback_method

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: emittance
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Tyler Guillen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-05 00:00:00.000000000 Z
+date: 2017-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,49 +25,49 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.15'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -124,11 +124,12 @@ files:
 - lib/emittance/emitter.rb
 - lib/emittance/errors.rb
 - lib/emittance/event.rb
-- lib/emittance/event/event_builder.rb
+- lib/emittance/event_lookup.rb
+- lib/emittance/helpers/constant_helpers.rb
+- lib/emittance/helpers/string_helpers.rb
 - lib/emittance/registration.rb
 - lib/emittance/version.rb
 - lib/emittance/watcher.rb
-- pkg/emittance-0.0.1.gem
 homepage: https://github.com/aastronautss/emittance
 licenses:
 - MIT

data/lib/emittance/event/event_builder.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-module Emittance
-  # @private
-  class Event
-    class EventBuilder
-      KLASS_NAME_SUFFIX = 'Event'
-
-      class << self
-        def klass_exists_for_identifier?(identifier)
-          klass_name = generate_event_klass_name identifier
-          !!lookup_event_klass(klass_name)
-        end
-
-        def objects_to_klass(*objs)
-          klass = nil
-
-          klass ||= pass_klass_through(*objs)
-          klass ||= find_by_custom_identifier(*objs)
-          klass ||= generate_event_klass(*objs)
-
-          klass
-        end
-
-        def klass_to_identifier(klass)
-          identifier = nil
-
-          identifier ||= reverse_find_by_custom_identifier(klass)
-          identifier ||= convert_klass_to_identifier(klass)
-
-          identifier
-        end
-
-        def register_custom_identifier(klass, identifier)
-          CustomIdentifiers.set identifier, klass
-        end
-
-        private
-
-        def pass_klass_through(*objs)
-          objs.length == 1 && objs[0].is_a?(Class) && objs[0] < Emittance::Event ? objs[0] : nil
-        end
-
-        def find_by_custom_identifier(*objs)
-          if objs.length == 1
-            CustomIdentifiers.event_klass_for objs[0]
-          else
-            nil
-          end
-        end
-
-        def reverse_find_by_custom_identifier(klass)
-          CustomIdentifiers.identifier_for klass
-        end
-
-        def generate_event_klass_name(*objs)
-          klass_name_parts = objs.map { |obj| klassable_name_for obj }
-          dress_up_klass_name klass_name_parts
-        end
-
-        def generate_event_klass(*objs)
-          klass_name = generate_event_klass_name(*objs)
-          find_or_create_event_klass klass_name
-        end
-
-        def convert_klass_to_identifier(klass)
-          identifier_str = klass.name
-          identifier_str = undress_klass_name identifier_str
-          identifier_str = snake_case identifier_str
-
-          identifier_str.to_sym
-        end
-
-        def klassable_name_for(obj)
-          name_str = obj.to_s
-          name_str = camel_case name_str
-          name_str = clean_up_punctuation name_str
-
-          name_str
-        end
-
-        def camel_case(str)
-          str = str.sub(/^[a-z\d]*/) { $&.capitalize }
-          str.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }
-        end
-
-        def snake_case(str)
-          str.gsub(/::/, '_')
-            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-            .gsub(/([a-z\d])([A-Z])/,'\1_\2')
-            .tr("-", "_")
-            .downcase
-        end
-
-        def clean_up_punctuation(str)
-          str.gsub /[^A-Za-z\d]/, ''
-        end
-
-        def dress_up_klass_name(klass_name_parts)
-          "#{Array(klass_name_parts).join}#{KLASS_NAME_SUFFIX}"
-        end
-
-        def undress_klass_name(klass_name_str)
-          klass_name_str.gsub /#{KLASS_NAME_SUFFIX}$/, ''
-        end
-
-        def lookup_event_klass(klass_name)
-          if Object.const_defined? klass_name
-            Object.const_get klass_name
-          else
-            nil
-          end
-        end
-
-        def find_or_create_event_klass(klass_name)
-          lookup_event_klass(klass_name) || create_event_klass(klass_name)
-        end
-
-        def create_event_klass(klass_name)
-          new_klass = Class.new(Emittance::Event)
-          Object.const_set klass_name, new_klass
-        end
-      end
-
-      class CustomIdentifiers
-        @mappings = {}
-
-        class << self
-          def mapping_exists?(identifier)
-            !!mappings[identifier] || Emittance::Event::EventBuilder.klass_exists_for_identifier?(identifier)
-          end
-
-          def event_klass_for(identifier)
-            mappings[identifier]
-          end
-
-          def identifier_for(event_klass)
-            mappings.key event_klass
-          end
-
-          def set(identifier, event_klass)
-            raise Emittance::InvalidIdentifierError, 'Event identifiers must be a Symbol.' unless identifier.is_a? Symbol
-            raise Emittance::IdentifierTakenError if mapping_exists? identifier
-            mappings[identifier] = event_klass
-          end
-
-          private
-
-          attr_reader :mappings
-        end
-      end
-    end
-  end
-end