seat-belt 0.10.0

data/lib/seatbelt/tape.rb

@@ -0,0 +1,2 @@
+require 'seatbelt/tapes/util/delegate'
+require 'seatbelt/tapes/tape'

data/lib/seatbelt/tape_deck.rb

@@ -0,0 +1,71 @@
+# -*- encoding : utf-8 -*-
+module Seatbelt
+
+  # A tape deck holds several tapes and 'plays' the section for a query.
+  # (See #respond for details.)
+  module TapeDeck
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+
+        private_class_method  :delegate_answer,
+                              :get_answer_from_tape
+      end
+    end
+
+    module ClassMethods
+      include Seatbelt::Tapes::Util::Delegate
+
+      # A store to hold tapes for the class that implements the module.
+      #
+      # Returns store.
+      def tapes
+        @tapes = [] if @tapes.nil?
+        @tapes
+      end
+
+      # Public: Adds a tape to the tape store. If a passed tape is already
+      # included in the store, it will not included a second time.
+      #
+      # tape_name - (class) name of the tape.
+      #
+      def use_tape(tape_name)
+        unless tape_name.in?(tapes)
+          unless tape_name.tape_deck.nil?
+            raise Seatbelt::Errors::MultipleTapeUsageDetectedError
+          end
+          tape_name.tape_deck.nil?
+          tape_name.tape_deck = Module.const_get(self.name)
+          tapes << tape_name
+        end
+      end
+      alias_method :add_tape, :use_tape
+
+      # Public: Adds a bunch of tapes to the store. See #use_tape.
+      #
+      # *tapes - A list of tapes.
+      #
+      def use_tapes(*tapes)
+        tapes.flatten.each { |tape| self.use_tape(tape) }
+      end
+
+      # Public: Detects an answer that matches the question and calls the
+      # translation block.
+      #
+      # question - The question or query as String
+      #
+      def respond(question)
+        found_answer = nil
+        tapes.each do |tape|
+          found_answer = get_answer_from_tape(tape, :question => question)
+          break if found_answer
+        end
+        raise Seatbelt::Errors::NoTapeFoundForQueryError unless found_answer
+        delegate_answer(found_answer, :question => question) if found_answer
+      end
+      alias_method :answer, :respond
+
+    end
+  end
+end

data/lib/seatbelt/tapes/tape.rb

@@ -0,0 +1,105 @@
+# -*- encoding : utf-8 -*-
+module Seatbelt
+  # Public: A Tape is a collection of translations to common queries.
+  # It's the base class of all tapes that provides handling the querys
+  # and delegating translations to other tapes.
+  #
+  # Example:
+  #
+  #   class HotelSampleTape < Seatbelt::Tape
+  #     translate /Show me (\d+) of the (\w+) in (\w+)/ do |sentence,
+  #                                                         count,
+  #                                                         price_type,
+  #                                                         location|
+  #       # do some code here ....
+  #     end
+  #   end
+  #
+  # A translation or answer to a query is defined with #translate following
+  # by a regular expression and a block.
+  #
+  # The block takes at least one argument. If the block argument list contains
+  # only one item then the item is the first machted data from the regular
+  # expression.
+  #
+  # If you want to have the original query and you expect matched data (at
+  # least one) than define your block argument list with at least two items
+  # where the first one is the query and the second, third ... are the
+  # matched data entries.
+  #
+  # Note that the extracted data from any query is passed to your translation
+  # block as a String, so you have to handle the type casts by yourself.
+  #
+  # To call other translation or delegate some values to a different
+  # translation at another tape use the #play_tape method within your
+  # #translation block.
+  #
+  # Example
+  #
+  #   translate /Send me (\d+) postcards from (\w+)/ do |sentence,
+  #                                                      post_card_count,
+  #                                                      location|
+  #     country = Region.find(:location => location)
+  #     amount  = play_tape(PostcardTape, :section => "send #{post_card_count}")
+  #
+  #     CardDispatcher.send_cards(:num => 2, :rate => amount,
+  #                               :lc => country.iso_code)
+  #   end
+  #
+  # Calls the /send (\d+)/ answer of the PostCardTape. The Tape has not to be
+  # attached with the own tape deck.
+  # If the first argument of #play_tape is omitted, any section of the
+  # current tape is called. Note that the section hash is needed.
+  class Tape
+    extend Seatbelt::Tapes::Util::Delegate
+
+    private_class_method  :delegate_answer,
+                          :get_answer_from_tape
+
+    class << self
+      # Public: Gets/Sets the tape deck of the tape.
+      attr_accessor :tape_deck
+    end
+
+    # A store to hold answers for the tape.
+    #
+    # Returns the store.
+    def self.answers
+      @answers = [] if @answers.nil?
+      @answers
+    end
+
+    # Public: Defines a translation implementation for a query/question.
+    #
+    # query  - A regular expression for identifying the question.
+    # &block - An implementation block.
+    #
+    def self.translate(query, &block)
+      answers << { :regex   => query,
+                   :action  => block }
+    end
+
+    # Public: Delegates or call another tape translation section.
+    #
+    # *args - An argument list containing:
+    #         tape (class)  - The tape to call (optional)
+    #         options       - A Hash to refine the :section (required)
+    #
+    def self.play_tape(*args)
+      options = args.extract_options!
+      tape    = args.pop
+      section = options[:section]
+
+      tape    = self if tape.nil?
+
+      answer  = get_answer_from_tape(tape, :question => section)
+      raise Seatbelt::Errors::NoTapeFoundForQueryError unless answer
+      delegate_answer(answer, :question => section)        if answer
+    end
+
+    class << self
+      alias_method :listen_to, :translate
+    end
+
+  end
+end

data/lib/seatbelt/tapes/util/delegate.rb

@@ -0,0 +1,56 @@
+module Seatbelt
+  module Tapes
+    module Util
+
+      # Public: Various methods to delegate answers or sections of a tape
+      # to corrosponding implementation.
+      # All methods are module methods and should be included as a class
+      # extension in a tape related class as private methods.
+      module Delegate
+
+        # Public: Calls the implementation block for a query.
+        #
+        # *args - An argument list containing
+        #         answer  - the answer implementation config
+        #                   (see Tape.translate for details)
+        #         options - A hash containing
+        #                   :question - The query question as String
+        #
+        # Returns the evaluated result of answer[:action].
+        def delegate_answer(*args)
+          options         = args.extract_options!
+          question        = options[:question]
+          answer          = args.pop
+          argument_length = answer[:action].arity - 1
+          data            = question.match(answer[:regex]).captures
+          first_data_item = if data.empty?
+            question
+          else
+            data.first
+          end
+          case argument_length
+            when 0 then answer[:action].call(first_data_item)
+            when 1 then answer[:action].call(question,data.first)
+            else answer[:action].call(question,*data)
+          end
+        end
+
+        # Public: Extracts an answer from a tape where the answer's regex
+        # matches the question string.
+        #
+        # tape        - A Tape class
+        # options={}  - A Hash containing
+        #               :question - The query question as String
+        #
+        # Returns a found answer or nil.
+        def get_answer_from_tape(tape, options={})
+          question = options[:question]
+          tape.answers.detect do |answer|
+            question.match(answer[:regex])
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/seatbelt/translator.rb

@@ -0,0 +1,66 @@
+module Seatbelt
+
+  # Public: Interface to the implementation sections of TQL.
+  # (TranslationQuery Language)
+  #
+  class Translator
+
+    class Config
+
+      def self.namespace
+        @namespace ||= ""
+      end
+
+      def self.namespace=(namespace)
+        @namespace =  namespace
+      end
+
+      def self.name_regex
+        @name_regex ||= /^\s*\w*[:,]/
+      end
+
+      def self.name_regex=(regexp)
+        @name_regex = regexp
+      end
+
+      def self.default_model_class
+        @default_model_class
+      end
+
+      def self.default_model_class=(klass)
+        @default_model_class = klass
+      end
+
+    end
+
+
+    def self.setup(&block)
+      yield(config)
+    end
+
+    def self.config
+      Translator::Config
+    end
+
+    # Public: Takes sentence an delegates it to the responding class.
+    #
+    # query - The natural language sentence as String.
+    #
+    # Example
+    #   Translator.tell_me "Hotel: Find the 2 cheapest near London"
+    #   Translator.tell_me "Offer: Find all for three weeks in Finnland"
+    #
+    # A query starts with the class name the query should pointed to following
+    # by ':'. If this is omitted the class defaults to Offer
+    def self.tell_me(query)
+      model_prefix  = config.namespace
+      name_regex    = config.name_regex
+      result        = query.scan(name_regex).first
+      klass         = result.gsub(":", "") if result.respond_to?(:gsub)
+      klass         = config.default_model_class unless klass
+      pattern       = query.gsub(name_regex, "").lstrip
+      Module.const_get("#{model_prefix}#{klass}").send(:respond,pattern)
+    end
+
+  end
+end

data/lib/seatbelt/version.rb

@@ -0,0 +1,3 @@
+module Seatbelt
+  VERSION = "0.10.0"
+end

data/seatbelt.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'seatbelt/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "seat-belt"
+  spec.version       = Seatbelt::VERSION
+  spec.authors       = ["Daniel Schmidt"]
+  spec.email         = ["dsci@code79.net"]
+  spec.description   = %q{Tool to define implementation interfaces that should be decoupled from their
+implementations. (A Ruby header file approach.)}
+  spec.summary       = %q{Define headers in your Ruby (we try to)}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency "activesupport"
+  spec.add_runtime_dependency "virtus", "~> 1.0.0"
+  spec.add_runtime_dependency "activemodel"
+end

data/spec/lib/seatbelt/core/eigenmethod_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Seatbelt::Eigenmethod do
+
+  it "provides #scope_level" do
+    expect(subject).to respond_to(:scope_level)
+    expect(subject).to respond_to(:scope_level=)
+  end
+
+  it "provides #receiver" do
+    expect(subject).to respond_to(:receiver)
+    expect(subject).to respond_to(:receiver=)
+  end
+
+  it "provides #namespace" do
+    expect(subject).to respond_to(:namespace)
+    expect(subject).to respond_to(:namespace=)
+  end
+
+  it "provides #implemented_as" do
+    expect(subject).to respond_to(:implemented_as)
+    expect(subject).to respond_to(:implemented_as=)
+  end
+
+  it "provides #method" do
+    expect(subject).to respond_to(:method=)
+  end
+
+  it "provides #method_implementation_type" do
+    expect(subject).to respond_to(:method_implementation_type=)
+    expect(subject).to respond_to(:method_implementation_type)
+  end
+
+  it "provides #call" do
+    expect(subject).to respond_to(:call)
+  end
+
+  it "provides #instance_level?" do
+    expect(subject).to respond_to(:instance_level?)
+  end
+
+  it "provides #class_level?" do
+    expect(subject).to respond_to(:class_level?)
+  end
+
+  it "provides #arity" do
+    expect(subject).to respond_to(:arity)
+  end
+
+  describe "#call" do
+    let(:proxy){ Seatbelt::Eigenmethod.new }
+    context "on instance level" do
+
+      before do
+        class Sample
+          def foo(a,b)
+            a*b
+          end
+        end
+        proxy.method          = Sample.instance_method(:foo)
+        proxy.receiver        = Sample
+        proxy.scope_level     = :instance
+        proxy.implemented_as  = :superfoo
+        proxy.instance_variable_set(:@callee, Sample.new)
+      end
+
+      it "calls the implemented method" do
+        expect(proxy.call(2,4)).to eq 8
+      end
+
+    end
+
+    context "on class level" do
+
+      before do
+        class NextSample
+          def self.count
+            return 12
+          end
+        end
+        proxy.method          = :count
+        proxy.receiver        = NextSample
+        proxy.scope_level     = :class
+        proxy.implemented_as  = :superfoo
+        proxy.method_implementation_type = :class
+      end
+
+      it "calls the implemented method" do
+        expect(proxy.call).to eq 12
+      end
+
+      context "calling instance method on class level" do
+        before do
+          class Sample
+          end
+        end
+      end
+
+    end
+  end
+
+end

data/spec/lib/seatbelt/core/gate_spec.rb

@@ -0,0 +1,521 @@
+require 'spec_helper'
+
+describe Seatbelt::Gate do
+  class ImplementsA
+    include Seatbelt::Gate
+  end
+
+  def stub_eigenmethods(*args)
+    opts = args.last.is_a?(Hash) ? args.pop : {}
+    return_value = opts.fetch(:return_value, [])
+    args.each do |klass|
+      klass.class.send(:define_method, :eigenmethods) do
+        return return_value
+      end
+    end
+  end
+
+  describe "class methods" do
+
+    it "provides #implement" do
+      expect(ImplementsA).to respond_to(:implement)
+    end
+
+    it "provides #synthesize" do
+      expect(ImplementsA).to respond_to(:synthesize)
+    end
+
+    it "provides #synthesize_map" do
+      expect(ImplementsA).to respond_to(:synthesize_map)
+    end
+
+    describe "#implement" do
+
+      before(:all) do
+        class A; end
+        module Vagalo; class Airport; end; end
+        stub_eigenmethods(A, Vagalo::Airport)
+      end
+
+      it "registers a logic method the the terminal" do
+        expect do
+          ImplementsA.class_eval do
+            def fetch_flight_time; end
+            implement :fetch_flight_time, :as => "A.flight_time"
+          end
+        end.to change{ Seatbelt::Terminal.luggage.size }.by(1)
+
+        config = Seatbelt::Terminal.luggage.last
+
+        expect(config).to have_key(:method)
+        expect(config).to have_key(:implemented_as)
+        expect(config).to have_key(:namespace)
+        expect(config).to have_key(:scope)
+
+        expect(config[:implemented_as]).to eq :flight_time
+        expect(config[:namespace]).to eq "A"
+        expect(config[:scope]).to eq :class
+      end
+
+      it "registers a logic method with module namespace and instance method" do
+        expect do
+          ImplementsA.class_eval do
+            def check_flight_to(destination); end
+            implement :check_flight_to, :as => "Vagalo::Airport#book_flight_to"
+          end
+        end.to change { Seatbelt::Terminal.luggage.size }.by(1)
+
+        config = Seatbelt::Terminal.luggage.last
+
+        expect(config[:namespace]).to eq "Vagalo::Airport"
+        expect(config[:scope]).to eq :instance
+        expect(config[:implemented_as]).to eq :book_flight_to
+
+      end
+
+    end
+
+  end
+
+  describe "instance methods" do
+
+    it "provides #proxy_object" do
+      expect(ImplementsA.new).to respond_to(:proxy_object)
+    end
+
+    describe "#proxy" do
+
+      before(:all) do
+
+        class Sky
+          def sky_color
+            'blue'
+          end
+        end
+
+        class ProxySample
+          include Seatbelt::Document
+          include Seatbelt::Ghost
+
+          attribute :name, String
+
+          interface :instance do
+            define :bar, :args => [:name]
+            define :foo
+            define :codecs, :args => [:num]
+            define :sky, :args => [:ff]
+          end
+
+        end
+
+        class ProxyImplementationSample
+          include Seatbelt::Gate
+          attr_accessor :airport_codes
+
+          delegate :sky_color, to: :@sky
+
+          implementation "ProxySample", :instance do
+            match 'implement_bar' => 'bar'
+            match 'implement_foo' => 'foo'
+            match 'implement_increase_airport_codes' => "codecs"
+            match 'sky_color' => 'sky', delegated: true
+            match 'shhh' => 'foo'
+          end
+
+          def initialize
+            @sky = Sky.new
+          end
+
+          def implement_bar(name)
+            @airport_codes = 12
+            proxy.name = name
+            return [proxy,self]
+          end
+
+          def implement_foo
+            return [proxy,self]
+          end
+
+          def implement_increase_airport_codes(num)
+            @airport_codes = num
+            return self
+          end
+
+        end
+
+      end
+
+      it "will not be the same object for multiple API class instances" do
+        first   = ProxySample.new(:name => "Foo")
+        second  = ProxySample.new(:name => "Bar")
+
+        first_proxy, first_imp   = first.bar("walter")
+        second_proxy, second_imp  = second.bar("hannes")
+
+        expect(first.codecs(99).airport_codes).to eq 99
+        expect(second.codecs(200).airport_codes).to eq 200
+#
+        expect(first_proxy).not_to be second_proxy
+        expect(first_proxy.name).to eq "walter"
+        expect(second_proxy.name).to eq "hannes"
+
+        expect(first_proxy.sky).to eq Sky.new.sky_color
+      end
+
+    end
+
+  end
+
+  describe "defining implementation classes" do
+
+    context "api methods on instance level" do
+
+      before(:all) do
+        class ApiFooSample
+          include Seatbelt::Document
+          include Seatbelt::Ghost
+
+          attribute :code, Integer
+
+          interface :instance do
+            define :sample_method1
+            define :sample_method2
+            define :sample_method3
+          end
+
+        end
+
+        class ImplementationApiFooSample
+          include Seatbelt::Gate
+
+          attr_accessor :codec
+
+          implementation "ApiFooSample", :instance do
+            match 'implementation_sample_method1' => 'sample_method1'
+            match 'implementation_sample_method2' => 'sample_method2'
+            match 'implementation_sample_method3' => 'sample_method3'
+          end
+
+          def initialize
+            @codec = "mp4"
+          end
+
+          def implementation_sample_method1
+            #p self.object_id
+            #p proxy
+            #puts caller
+            #p "in implementation method"
+            #p proxy.object_id
+            return proxy,self, codec
+          end
+
+          def implementation_sample_method2
+            #p self.object_id
+            @codec = "divx"
+            return proxy,self, codec
+          end
+
+          def implementation_sample_method3
+            return proxy,self, codec
+          end
+
+        end
+      end
+
+      context "implementing multiple methods within the same namespace" do
+
+        it "uses the same proxy object" do
+          api = ApiFooSample.new(:code => 911)
+          api2 = ApiFooSample.new(:code => 112)
+
+          api2_proxy1,api2_object1, api_code2 = api2.sample_method1
+          api1_proxy1,api1_object1, api_code1 = api.sample_method1
+
+          sample_method1_proxy, sample_method1_object,code1 = api.sample_method1
+          sample_method2_proxy, sample_method2_object,code2 = api.sample_method2
+          sample_method3_proxy, sample_method3_object,code3 = api.sample_method3
+
+          expect(sample_method1_object.object_id).to eq sample_method2_object.object_id
+          expect(sample_method1_object).to eq sample_method3_object
+          expect(sample_method2_object).to eq sample_method3_object
+
+          expect(sample_method1_proxy).to eq sample_method2_proxy
+          expect(sample_method1_proxy).to eq sample_method3_proxy
+          expect(sample_method2_proxy).to eq sample_method3_proxy
+
+          expect(sample_method1_proxy.code).to eq 911
+
+          expect(code1).to eq "mp4"
+          expect(code2).to eq "divx"
+          expect(code3).to eq "divx"
+
+        end
+
+      end
+
+      context "implementing multiple methods within several namespaces" do
+
+        before(:all) do
+
+          class ApiBarSample
+            include Seatbelt::Ghost
+
+            interface :instance do
+              define :method1
+            end
+
+          end
+
+          ImplementationApiFooSample.class_eval do
+            implementation "ApiBarSample", :instance do
+              match 'implement_with_other_namespace' => 'method1'
+            end
+
+            def implement_with_other_namespace
+              return proxy, self
+            end
+          end
+
+        end
+
+        it "every method has its own proxy scope" do
+          apibar  = ApiBarSample.new
+          api     = ApiFooSample.new(:code => 911)
+
+          apibar_proxy = apibar.method1.first
+          api_proxy    = api.sample_method1.first
+
+          expect(apibar_proxy).not_to be api_proxy
+        end
+
+        it "every method namespace has its own instance" do
+          apibar  = ApiBarSample.new
+          api     = ApiFooSample.new(:code => 911)
+
+          apibar_object = apibar.method1[1]
+          api_object    = api.sample_method1[1]
+
+          expect(apibar_object).not_to be api_object
+        end
+      end
+
+      context "methods of superclass of the implementation class" do
+
+        before(:all) do
+          class ApiInheritanceSample
+            include Seatbelt::Ghost
+
+            interface :instance do
+              define :hello_world, :args => [:name]
+            end
+          end
+
+          class ImplementationSuperClass
+
+            def implementation_world(name)
+              "Hello #{name}!"
+            end
+
+          end
+
+          class ImplementationChildClass < ImplementationSuperClass
+            include Seatbelt::Gate
+
+            implementation "ApiInheritanceSample", :instance do
+              match 'implementation_world' => 'hello_world', :superclass=>true
+            end
+
+          end
+        end
+
+        it "evaluates the method defined in the superclass" do
+          inheritance_sample = ApiInheritanceSample.new
+          expected = "Hello Max!"
+          expect(inheritance_sample.hello_world("Max")).to eq expected
+        end
+
+      end
+    end
+
+    context "api methods on class level" do
+      before(:all) do
+        class ClassLevel
+          include Seatbelt::Ghost
+
+          interface :class do
+            define :all
+          end
+        end
+        class ImplementationClassLevel
+
+          include Seatbelt::Gate
+
+          implementation "ClassLevel", :class do
+            match 'all' => 'all'
+          end
+
+          def self.all
+            return "12"
+          end
+          #implement :all, :as => "ClassLevel.all"
+        end
+      end
+
+      it "evaluates the class method" do
+        expect(ClassLevel.all).to eq "12"
+      end
+    end
+
+    context "accessing implemenation attributes" do
+
+      context "with using proxy#tunnel" do
+
+        before(:all) do
+          class ApiB
+            include Seatbelt::Document
+            include Seatbelt::Ghost
+
+            api_method :foobar
+            api_method :bar
+          end
+          class ApiA
+            include Seatbelt::Document
+            include Seatbelt::Ghost
+
+            has :b, ApiB
+            api_method :my_delegating
+            api_method :init_b
+          end
+
+          class ImplementationA
+            include Seatbelt::Gate
+
+            def init_b
+              proxy.b = ApiB.new
+            end
+            implement :init_b,
+                      :as => "ApiA#init_b"
+
+            def implement_my_delegating
+              proxy.tunnel("b.nice_looking")
+            end
+            implement :implement_my_delegating,
+                      :as => "ApiA#my_delegating"
+          end
+
+          class ImplementationB
+            include Seatbelt::Document
+            include Seatbelt::Gate
+
+            attribute :nice_looking, String, :default => "Black"
+
+            def implement_foobar
+
+            end
+            implement :implement_foobar,
+                      :as => "ApiB#foobar"
+
+            def implement_bar
+
+            end
+            implement :implement_bar,
+                      :as => "ApiB#bar"
+          end
+        end
+
+        it "calls another implementation attribute or method" do
+          api = ApiA.new
+          api.init_b
+          expect(api.my_delegating).to eq "Black"
+        end
+
+      end
+
+    end
+
+    context "property matching" do
+
+      context "using #match_property" do
+
+        context "with string as argument" do
+
+          class PropertyFoo
+            include Seatbelt::Ghost
+            interface :instance do
+              define_property :foo
+              define_property :foobar
+            end
+          end
+
+          class ImplementationPropertyFooParent
+
+            attr_accessor :foobar
+
+          end
+
+          class ImplementationPropertyFoo < ImplementationPropertyFooParent
+            include Seatbelt::Gate
+            include Seatbelt::Document
+            implementation "PropertyFoo", :instance do
+              match_property :foobar, :superclass => true
+              match_property :foo
+            end
+
+            attr_accessor :foo
+
+          end
+
+          it "matches identical named getter and setters" do
+            property_foo = PropertyFoo.new
+            property_foo.foo = 100
+            property_foo.foobar = 10
+            expect(property_foo.foo).to eq 100
+            expect(property_foo.foobar).to eq 10
+          end
+
+        end
+
+        context "with hash as argument" do
+
+          class PropertyBar
+            include Seatbelt::Ghost
+            interface :instance do
+              define_property :bar
+              define_property :real_world
+            end
+          end
+
+          class ImplementationPropertyParent
+
+            attr_accessor :super_foo
+
+          end
+
+          class ImplementationPropertyBar < ImplementationPropertyParent
+            include Seatbelt::Gate
+            include Seatbelt::Document
+            implementation "PropertyBar", :instance do
+              match_property 'implement_bar_accessor' => 'bar'
+              match_property 'super_foo' => 'real_world', :superclass => true
+            end
+
+            attr_accessor :implement_bar_accessor
+
+          end
+
+          it "matches the explicitly named getter and setter" do
+            property_foo = PropertyBar.new
+            property_foo.bar = 100
+            property_foo.real_world = "England"
+            expect(property_foo.bar).to eq 100
+            expect(property_foo.real_world).to eq "England"
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end