hypercuke 0.4.1

data/lib/hypercuke/cli/parser.rb

@@ -0,0 +1,76 @@
+module Hypercuke
+  class CLI
+
+    # I extract relevant information from a 'hcu' command line
+    class Parser
+      attr_reader :options
+      def initialize(hcu_command)
+        @tokens = tokenize(hcu_command)
+        parse_options
+      end
+
+      def layer_name
+        options[:layer_name]
+      end
+
+      private
+      attr_reader :tokens
+
+      def parse_options
+        @options = Hash.new
+
+        ignore_hcu
+        set_layer_name
+        set_mode_if_present
+        set_profile_if_present
+        set_other_args
+
+        options
+      end
+
+      def tokenize(input)
+        args =
+          case input
+          when Array  ; input
+          when String ; input.split(/\s+/) # That's 4 years of CS education right there, baby
+          else fail "Don't know how to parse #{input.inspect}"
+          end
+        args.compact
+      end
+
+      # We might get the 'hcu' command name itself; just drop it on the floor
+      def ignore_hcu
+        tokens.shift if tokens.first =~ /\bhcu$/i
+      end
+
+      # This is the only required argument.
+      # TODO: Validate this against the list of known layers?
+      #       ^ Would require loading local app's hypercuke config.
+      #       ^ Would require allowing local app to *have* hypercuke config.
+      def set_layer_name
+        fail "Layer name is required" if tokens.empty?
+        options[:layer_name] = tokens.shift
+      end
+
+      def set_mode_if_present
+        unless tokens.first =~ /^-/
+          options[:mode] = tokens.shift
+        end
+      end
+
+      def set_profile_if_present
+        if profile_index = ( tokens.index('--profile') || tokens.index('-p') )
+          tokens.delete_at(profile_index) # don't care
+          options[:profile] = tokens.delete_at(profile_index)
+        end
+      end
+
+      def set_other_args
+        options[:other_args] = Array.new.tap do |rest|
+          rest << tokens.shift until tokens.empty?
+        end
+      end
+    end
+
+  end
+end

data/lib/hypercuke/config.rb

@@ -0,0 +1,20 @@
+module Hypercuke
+
+  class Config
+    attr_reader :layers, :topics
+    def initialize
+      @layers = NameList.new
+      @topics = NameList.new
+    end
+
+    def layer_names
+      layers.to_a
+    end
+
+    def topic_names
+      topics.to_a
+    end
+
+  end
+
+end

data/lib/hypercuke/context.rb

@@ -0,0 +1,36 @@
+require 'forwardable'
+
+module Hypercuke
+  # I provide a way of passing state around between tests
+  # that isn't instance variables.
+  #
+  # This is handy even in plain old Cucumber-land (where if you typo an
+  # instance variable, you just get nil), and essential in a set of
+  # mostly-independent step adapter objects, each with their own private
+  # state.
+  class Context
+    def initialize
+      @hash = {}
+    end
+
+    extend Forwardable
+    # I support:
+    # - Hash-style getting and setting via square brackets,
+    # - fetch (as a pass-through to Hash),
+    def_delegators :@hash, *[
+      :[],
+      :[]=,
+      :fetch,
+    ]
+
+    # - And a variant of fetch that, if the key is not found, sets it
+    #   for the next caller.
+    #
+    # This behavior is in the spirit of the ||= operator, except that
+    # it won't short-circuit and call the default value if the key is
+    # present, but set to nil or false.
+    def fetch_or_default(key, &block)
+      @hash[key] = @hash.fetch(key, &block)
+    end
+  end
+end

data/lib/hypercuke/cucumber_integration.rb

@@ -0,0 +1,15 @@
+# NOTE:  this file should not be required from the Hypercuke gem itself.
+# It's intended to be required from within the Cucumber environment
+# (e.g., in features/support/env.rb or equivalent).
+
+module Hypercuke
+  module CucumberIntegration
+    module WorldMixin
+      def step_driver
+        @step_driver ||= Hypercuke::StepDriver.new
+      end
+    end
+  end
+end
+
+World( Hypercuke::CucumberIntegration::WorldMixin )

data/lib/hypercuke/exceptions.rb

@@ -0,0 +1,42 @@
+module Hypercuke
+  module Error
+    def self.included(receiver)
+      receiver.extend ClassMethods
+    end
+
+    module ClassMethods
+      def wrap(exception)
+        message = translate_message(exception.message)
+        new(message).tap do |wrapping_exception|
+          wrapping_exception.set_backtrace exception.backtrace
+        end
+      end
+
+      def translate_message(message)
+        message # just here to be overridden
+      end
+    end
+  end
+
+  class LayerNotDefinedError < NameError
+    include Hypercuke::Error
+  end
+
+  class TopicNotDefinedError < NameError
+    include Hypercuke::Error
+  end
+
+  class StepAdapterNotDefinedError < NameError
+    include Hypercuke::Error
+
+    def self.translate_message(message)
+      step_adapter_name = 
+        if md = /(Hypercuke::StepAdapters::\S*)/.match(message)
+          md.captures.first
+        else
+          message
+        end
+      "Step adapter not defined: '#{step_adapter_name}'"
+    end
+  end
+end

data/lib/hypercuke/mini_inflector.rb

@@ -0,0 +1,9 @@
+module Hypercuke
+  module MiniInflector
+    extend self
+
+    def camelize(name)
+      name.to_s.split('_').map(&:capitalize).join
+    end
+  end
+end

data/lib/hypercuke/name_list.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+
+module Hypercuke
+  class NameList
+    attr_reader :names
+    private :names
+
+    def initialize(*names)
+      @names = names.flatten
+    end
+
+    def define(new_name)
+      name = new_name.to_sym
+      names << name unless names.include?(name)
+    end
+
+    def validate(name)
+      if valid_name?(name)
+        return name.to_sym
+      else
+        yield if block_given?
+        return nil
+      end
+    end
+
+    def valid_name?(name)
+      names.include?(name.to_sym)
+    end
+
+    def to_a
+      names.dup
+    end
+
+    def empty?
+      names.empty?
+    end
+  end
+end

data/lib/hypercuke/step_adapter.rb

@@ -0,0 +1,12 @@
+module Hypercuke
+  # I am the superclass for all of the generated step adapters.
+  class StepAdapter
+    def initialize(context, step_driver)
+      @context     = context
+      @step_driver = step_driver
+    end
+
+    private
+    attr_reader :context, :step_driver
+  end
+end

data/lib/hypercuke/step_adapters.rb

@@ -0,0 +1,126 @@
+module Hypercuke
+  # Greetings, dear reader.  There's a lot going in this file, so it's
+  # been organized in a more conversational style than most of the Ruby
+  # code I write.  I hope it helps.
+
+  # First things first:  the point of this entire file.
+  #
+  # Should you find yourself in possession of a [topic, layer] name
+  # pair, this method allows you to redeem it for VALUABLE PRIZES!  (And
+  # by "valuable prizes", I mean "a reference to a step adapter class,
+  # if one has already been defined.")
+  #
+  # This method (on Hypercuke itself) is but a facade...
+  def self.step_adapter_class(topic_name, layer_name)
+    topic_module = StepAdapters.fetch_topic_module(topic_name)
+    topic_module.fetch_step_adapter(layer_name)
+  end
+
+  # We start out with a namespace for step adapters.  As new step
+  # adapter classes are created (see Hypercuke::AdapterDefinition), they
+  # will be assigned to constants in this module's namespace (so that
+  # they can have human-friendly names when something goes wrong and
+  # #inspect gets called on them).
+  #
+  # Class names will be of the form:
+  # Hypercuke::StepAdapters::<TopicName>::<LayerName>
+  module StepAdapters
+    extend self # BTW, I hate typing "self." in modules.
+
+    # We'll get to what makes a topic module special is in a moment, but
+    # here's how we fetch one:
+    def fetch_topic_module(topic_name)
+      # FIXME: cyclomatic complexity
+      Hypercuke.topics.validate(topic_name) do
+        fail TopicNotDefinedError, "Topic not defined: #{topic_name}"
+      end
+      validate_topic_module \
+        begin
+          const_get( MiniInflector.camelize(topic_name) )
+        rescue NameError => e
+          raise Hypercuke::TopicNotDefinedError.wrap(e)
+        end
+    end
+
+    private
+
+    def validate_topic_module(candidate)
+      return candidate if candidate.kind_of?(::Hypercuke::TopicModule)
+      fail Hypercuke::TopicNotDefinedError
+    end
+  end
+
+  # So, a TopicModule is (a) a namespace for holding step adapters, and
+  # (b) a slightly specialized type of Module that knows enough to be
+  # able to fetch step adapters.
+  class TopicModule < Module
+    def fetch_step_adapter(layer_name)
+      # FIXME: cyclomatic complexity
+      Hypercuke.layers.validate(layer_name) do
+        fail LayerNotDefinedError, "Layer not defined: #{layer_name}"
+      end
+      validate_step_adapter \
+        begin
+          const_get( MiniInflector.camelize(layer_name) )
+        rescue NameError => e
+          raise Hypercuke::StepAdapterNotDefinedError.wrap(e)
+        end
+    end
+
+    private
+
+    def validate_step_adapter(candidate)
+      return candidate if candidate.kind_of?(Class) && candidate.ancestors.include?(::Hypercuke::StepAdapter)
+      fail Hypercuke::StepAdapterNotDefinedError
+    end
+  end
+
+  # Okay.  That covers fetching step adapters once they've been defined.
+  # Now let's talk about how we define new ones.
+
+  module StepAdapters
+    # Here's the entry point for the adapter definition API.  It's
+    # entirely possible that a user might want to define their step
+    # adapters in a re-entrant way (much like we've been reopening the
+    # same modules and classes in this file), so this bit of the code
+    # will either create a new step adapter, or return one that's
+    # already been defined.
+    def define(topic_name, layer_name)
+      topic_module = define_topic_module(topic_name)
+      step_adapter = topic_module.define_step_adapter( layer_name )
+    end
+  end
+
+  # The next two bits follow this pattern:
+  # 1) attempt to fetch the requested thing.
+  # 2) if fetch fails, define and return it.
+
+  module StepAdapters
+    def define_topic_module(topic_name)
+      fetch_topic_module(topic_name)
+    rescue Hypercuke::TopicNotDefinedError
+      const_name = MiniInflector.camelize(topic_name)
+      const_set const_name, TopicModule.new
+    end
+  end
+
+  class TopicModule < Module
+    def define_step_adapter(layer_name)
+      fetch_step_adapter(layer_name)
+    rescue Hypercuke::StepAdapterNotDefinedError
+      const_name = MiniInflector.camelize(layer_name)
+      const_set const_name, Class.new(StepAdapter)
+    end
+  end
+
+  # One final bit of business before we go: when testing code that
+  # defines classes and binds them to constants, it is occasionally
+  # useful to reset to a blank slate.
+  module StepAdapters
+    def clear
+      constants.each do |c|
+        remove_const c
+      end
+    end
+  end
+end

data/lib/hypercuke/step_driver.rb

@@ -0,0 +1,52 @@
+module Hypercuke
+
+  # The step driver serves as the entry point from Cucumber step
+  # definition bodies to the Hypercuke API.  An instance of this object
+  # will be made available to Cucumber::World via the #step_driver
+  # method.  
+  #
+  # The StepDriver will interpret any message sent to it as a topic
+  # name, combine that with the current_layer name from Hypercuke, and
+  # use that to instantitate a StepAdapter for the appropriate
+  # topic/layer combo.
+  class StepDriver
+    def layer_name
+      Hypercuke.current_layer
+    end
+
+    def method_missing(method, *_O) # No arguments for you, Mister Bond! *adjusts monocle*
+      topic_name = method.to_sym
+
+      # Define a method for the topic name so that future requests for
+      # the same step adapter don't pay the method_missing tax.
+      self.class.send(:define_method, topic_name) do
+        # Within the defined method, memoize the step adapter so that
+        # future requests also don't pay the GC tax.
+        key = [topic_name, layer_name] # key on both names in case someone changes the layer on us
+        __step_adapters__[key] ||=
+          begin
+            klass = Hypercuke.step_adapter_class(*key)
+            klass.new(__context__, self)
+          end
+      end
+
+      # And don't forget to invoke the newly-created method.
+      send(method)
+    end
+
+    # StepDriver is eager to please.
+    def respond_to_missing?(_)
+      true
+    end
+
+    private
+
+    def __context__
+      @__context__ ||= Hypercuke::Context.new
+    end
+
+    def __step_adapters__
+      @__step_adapters__ ||= {}
+    end
+  end
+end

data/lib/hypercuke/version.rb

@@ -0,0 +1,3 @@
+module Hypercuke
+  VERSION = "0.4.1"
+end