sinclair 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b59fc038965ca4d716620bcdba5e7cb3eb250b6d
-  data.tar.gz: 060a5b3eaf6b829a4b3cd97acdf6465cab863e06
+  metadata.gz: e2734e2007f6c98dc270ea39df18e07aed7f9324
+  data.tar.gz: d570bf309c48f65b080b0db7da0301968fb055c4
 SHA512:
-  metadata.gz: 1846ce94184b85e892a2c3ec24c5420f159bcf330b377d0f4694cb4e5c06779fd4d03cc35bed5967a7799761408416c76d6b82eae270e5b105c3e941634f9c95
-  data.tar.gz: 0e348b3209b78b692d9a98f6badf4f77a4e52f27e230f24b7d6257dd326be20ce64f0c9a6aa33cfcdc8ff32007e86047bbe8354dbc09e37cf4bb73c163a0d76e
+  metadata.gz: 4cbe6a2654818eedc3aac238d6689e61210d1e2fe9ad1dfc892bc340474b9ccc49a1474a2fa4e69dabf3dd3975ddc003120cc2a7db31c4a32b74ea3b55fc8924
+  data.tar.gz: daf0ff8fbe75d336c0651dc27298b530a12b1c2709e67b3a6b2dd3c64407a5ddbb1ff14d0a92dd018a3df4f1f143508c0812e4075f4317a0f2105b214dc01f49

data/.gitignore

@@ -2,3 +2,5 @@ coverages
 pkg
 Gemfile.lock
 coverage
+doc
+.yardoc/

data/.rubocop_todo.yml

@@ -111,8 +111,6 @@ Metrics/BlockLength:
 # SupportedStyles: nested, compact
 Style/ClassAndModuleChildren:
   Exclude:
-    - 'lib/sinclair/method_definition.rb'
-    - 'lib/sinclair/options_parser.rb'
     - 'spec/support/models/dummy_builder.rb'
     - 'spec/support/models/dummy_options_parser.rb'
 

data/README.md

@@ -33,34 +33,38 @@ The concern builder can actully be used in two ways, as an stand alone object ca
 adding methods to your class or by extending it for more complex logics
 
  - Stand Alone usage:
-```ruby
-  class Clazz
-  end
 
-  builder = Sinclair.new(Clazz)
+  ```ruby
 
-  builder.add_method(:twenty, '10 + 10')
-  builder.add_method(:eighty) { 4 * twenty }
-  builder.build
+    class Clazz
+    end
 
-  instance = Clazz.new
+    builder = Sinclair.new(Clazz)
 
-  puts "Twenty => #{instance.twenty}"
-  puts "Eighty => #{instance.eighty}"
-```
+    builder.add_method(:twenty, '10 + 10')
+    builder.add_method(:eighty) { 4 * twenty }
+    builder.build
 
-```string
-  Twenty => 20
-  Eighty => 80
-```
+    instance = Clazz.new
+
+    puts "Twenty => #{instance.twenty}"
+    puts "Eighty => #{instance.eighty}"
+  ```
+
+  ```string
+
+    Twenty => 20
+    Eighty => 80
+  ```
 
  - Extending the builder
 
   ```ruby
+
     class ValidationBuilder < Sinclair
       delegate :expected, to: :options_object
 
-      def initialize(clazz, options={})
+      def initialize(klass, options={})
         super
       end
 
@@ -69,7 +73,7 @@ adding methods to your class or by extending it for more complex logics
       end
 
       def add_accessors(fields)
-        clazz.send(:attr_accessor, *fields)
+        klass.send(:attr_accessor, *fields)
       end
     end
 
@@ -119,42 +123,32 @@ adding methods to your class or by extending it for more complex logics
   ```
 
   the instance will respond to the methods
-```name``` ```name=``` ```name_valid?```
-```surname``` ```surname=``` ```surname_valid?```
-```age``` ```age=``` ```age_valid?```
-```legs``` ```legs=``` ```legs_valid?```
-```valid?```
+  ```name``` ```name=``` ```name_valid?```
+  ```surname``` ```surname=``` ```surname_valid?```
+  ```age``` ```age=``` ```age_valid?```
+  ```legs``` ```legs=``` ```legs_valid?```
+  ```valid?```
 
   ```ruby
+
     valid_object = MyClass.new(
       name: :name,
       surname: 'surname',
       age: 20,
       legs: 2
     )
-    valid_object.valid?
-  ```
-
-  returns
-
-  ```
-  true
+    valid_object.valid? # returns true
   ```
 
   ```ruby
+
     invalid_object = MyClass.new(
       name: 'name',
       surname: 'surname',
       age: 20,
       legs: 2
     )
-    invalid_object.valid?
-  ```
-
-  returns
-
-  ```
-  false
+    invalid_object.valid? # returns false
   ```
 
 RSspec matcher
@@ -162,64 +156,67 @@ RSspec matcher
 
 You can use the provided matcher to check that your builder is adding a method correctly
 
-```ruby
-class DefaultValue
-  delegate :build, to: :builder
-  attr_reader :klass, :method, :value
+  ```ruby
 
-  def initialize(klass, method, value)
-    @klass = klass
-    @method = method
-    @value = value
-  end
+  class DefaultValue
+    delegate :build, to: :builder
+    attr_reader :klass, :method, :value
+
+    def initialize(klass, method, value)
+      @klass = klass
+      @method = method
+      @value = value
+    end
 
-  private
+    private
 
-  def builder
-    @builder ||= Sinclair.new(klass).tap do |b|
-      b.add_method(method) { value }
+    def builder
+      @builder ||= Sinclair.new(klass).tap do |b|
+        b.add_method(method) { value }
+      end
     end
   end
-end
-
-RSpec.configure do |config|
-  config.include Sinclair::Matchers
-end
-
-RSpec.describe DefaultValue do
-  let(:klass)    { Class.new }
-  let(:method)   { :the_method }
-  let(:value)    { Random.rand(100) }
-  let(:builder)  { described_class.new(klass, method, value) }
-  let(:instance) { klass.new }
-
-  context 'when the builder runs' do
-    it do
-      expect do
-        described_class.new(klass, method, value).build
-      end.to add_method(method).to(instance)
-    end
+
+  RSpec.configure do |config|
+    config.include Sinclair::Matchers
   end
 
-  context 'when the builder runs' do
-    it do
-      expect do
-        described_class.new(klass, method, value).build
-      end.to add_method(method).to(klass)
+  RSpec.describe DefaultValue do
+    let(:klass)    { Class.new }
+    let(:method)   { :the_method }
+    let(:value)    { Random.rand(100) }
+    let(:builder)  { described_class.new(klass, method, value) }
+    let(:instance) { klass.new }
+
+    context 'when the builder runs' do
+      it do
+        expect do
+          described_class.new(klass, method, value).build
+        end.to add_method(method).to(instance)
+      end
+    end
+
+    context 'when the builder runs' do
+      it do
+        expect do
+          described_class.new(klass, method, value).build
+        end.to add_method(method).to(klass)
+      end
     end
   end
-end
-```
+  ```
 
-```bash
-> bundle exec rspec
-```
+  ```bash
 
-```string
-DefaultValue
-  when the builder runs
-      should add method 'the_method' to #<Class:0x0000000146c160> instances
-  when the builder runs
-      should add method 'the_method' to #<Class:0x0000000143a1b0> instances
+  > bundle exec rspec
+  ```
+
+  ```string
 
-```
+  DefaultValue
+    when the builder runs
+        should add method 'the_method' to #<Class:0x0000000146c160> instances
+    when the builder runs
+        should add method 'the_method' to #<Class:0x0000000143a1b0> instances
+
+  ```

data/lib/sinclair.rb

@@ -1,6 +1,25 @@
 require 'active_support'
 require 'active_support/all'
 
+# Builder that add instance methods to a class
+#
+# @example
+#
+#   class MyModel
+#   end
+#
+#   buider = Sinclair.new(MyModel)
+#
+#   value = 10
+#   builder.add_method(:default_value) { value }
+#   builder.add_method(:value, '@value || default_value')
+#   builder.add_method(:value=) { |val| @value = val }
+#   builder.build
+#
+#   instance = MyModel.new
+#   instance.value # returns 10
+#   instance.value = 20
+#   instance.value # returns 20
 class Sinclair
   require 'sinclair/options_parser'
 
@@ -10,29 +29,166 @@ class Sinclair
 
   include OptionsParser
 
-  attr_reader :clazz
-
-  def initialize(clazz, options = {})
-    @clazz = clazz
+  # @param klass [Class] to receive the methods
+  # @param options [Hash] open hash options to be used by builders inheriting from Sinclair
+  #   through the Sinclair::OptionsParser concern
+  #
+  # @example
+  #
+  #   class Purchase
+  #     def initialize(value, quantity)
+  #       @value = value
+  #       @quantity = quantity
+  #     end
+  #   end
+  #
+  #   builder = Sinclair.new(Purchase)
+  #
+  # @example
+  #
+  #   builder = Sinclair.new(Purchase, rescue_error: true)
+  def initialize(klass, options = {})
+    @klass = klass
     @options = options
   end
 
+  # builds all the methods added into the klass
+  #
+  # @example
+  #
+  #   class MyModel
+  #   end
+  #
+  #   buider = Sinclair.new(MyModel)
+  #
+  #   builder.add_method(:default_value) { value }
+  #
+  #   MyModel.new.respond_to(:default_value) # returns false
+  #
+  #   builder.build
+  #
+  #   MyModel.new.respond_to(:default_value) # returns true
   def build
     definitions.each do |definition|
-      definition.build(clazz)
+      definition.build(klass)
     end
   end
 
+  # add a method to the method list to be created on klass
+  #
+  # @overload add_method(name, code)
+  #   @param name [String/Symbol] name of the method to be added
+  #   @param code [String] code to be evaluated when the method is ran
+  #
+  #   @example
+  #     class Person
+  #       attr_reader :first_name, :last_name
+  #
+  #       def initialize(first_name, last_name)
+  #         @first_name = first_name
+  #         @last_name = last_name
+  #       end
+  #     end
+  #
+  #     builder = Sinclair.new(Person)
+  #     builder.add_method(:full_name, '[first_name, last_name].join(" ")')
+  #     builder.build
+  #
+  #     Person.new('john', 'wick').full_name # returns 'john wick'
+  #
+  # @overload add_method(name, &block)
+  #   @param name [String/Symbol] name of the method to be added
+  #   @param block [Proc]  block to be ran as method
+  #
+  #   @example
+  #
+  #     builder = Sinclair.new(Person)
+  #     builder.add_method(:bond_name) { "#{last_name}, #{full_name}" }
+  #     builder.build
+  #
+  #     Person.new('john', 'wick').bond_name # returns 'wick, john wick'
   def add_method(name, code = nil, &block)
     definitions << MethodDefinition.new(name, code, &block)
   end
 
+  # evaluetes a block which will result in a [String] to be
+  # then used as code for the method
+  #
+  # @example
+  #
+  #   module InitialValuer
+  #     extend ActiveSupport::Concern
+  #
+  #     class_methods do
+  #       def initial_value_for(attribute, value)
+  #         builder = Sinclair.new(self, initial_value: value)
+  #         builder.eval_and_add_method(attribute) do
+  #           "@#{attribute} ||= #{options_object.initial_value}"
+  #         end
+  #         builder.build
+  #       end
+  #     end
+  #   end
+  #
+  #   class MyClass
+  #     include InitialValuer
+  #     attr_writer :age
+  #     initial_value_for :age, 20
+  #   end
+  #
+  #   object = MyClass.new
+  #   object.age # 20
+  #   object.age = 30
+  #   object.age # 30
+  #
+  # @example
+  #
+  #   class Purchase
+  #     def initialize(value, quantity)
+  #       @value = value
+  #       @quantity = quantity
+  #     end
+  #   end
+  #
+  #   builder = Sinclair.new(Purchase)
+  #
+  #   builder.eval_and_add_method(:total_price) do
+  #     code = 'self.value * self.quantity'
+  #     code.concat ' rescue 0' if options_object.rescue_error
+  #     code
+  #   end
+  #
+  #   builder.build
+  #
+  #   Purchase.new(2.3, 5).total_price # raises error
+  #
+  # @example
+  #
+  #   builder = Sinclair.new(Purchase, rescue_error: true)
+  #
+  #   builder.eval_and_add_method(:total_price) do
+  #     code = 'self.value * self.quantity'
+  #     code.concat ' rescue 0' if options_object.rescue_error
+  #     code
+  #   end
+  #
+  #   builder.build
+  #
+  #   Purchase.new(2.3, 5).total_price # returns 0
+  #
+  #   class Purchase
+  #     attr_reader :value, :quantity
+  #   end
+  #
+  #   Purchase.new(2.3, 5).total_price # returns 11.5
   def eval_and_add_method(name, &block)
     add_method(name, instance_eval(&block))
   end
 
   private
 
+  attr_reader :klass
+
   def definitions
     @definitions ||= []
   end

data/lib/sinclair/matchers.rb

@@ -1,8 +1,33 @@
 class Sinclair
+  # Matchers module will have the DSL to be included in RSpec in order to have
+  # access to the matchers
+  #
+  # @example
+  #  RSpec.configure do |config|
+  #    config.include Sinclair::Matchers
+  #  end
+  #
+  #  class MyModel
+  #  end
+  #
+  #  RSpec.describe 'my test' do
+  #    let(:klass)   { Class.new(MyModel) }
+  #    let(:builder) { Sinclair.new(klass) }
+  #
+  #    before do
+  #      builder.add_method(:class_name, 'self.class.name')
+  #    end
+  #
+  #    it do
+  #      expect { builder.build }.to add_method(:class_name).to(klass)
+  #    end
+  #  end
   module Matchers
     autoload :AddMethod,   'sinclair/matchers/add_method'
     autoload :AddMethodTo, 'sinclair/matchers/add_method_to'
 
+    # DSL to AddMethod
+    # @return [AddMethod] RSpec Matcher
     def add_method(method)
       Sinclair::Matchers::AddMethod.new(method)
     end

data/lib/sinclair/matchers/add_method.rb

@@ -1,19 +1,29 @@
 class Sinclair
   module Matchers
+    # AddMethod is able to build an instance of Sinclair::Matchers::AddMethodTo
     class AddMethod < RSpec::Matchers::BuiltIn::BaseMatcher
-      attr_reader :method
-
+      # as any matcher is expected to implement matches?, we raise a warning on the usage as
+      # this is only a builder for AddMethodTo
       def matches?(_actual)
         raise SyntaxError, 'You should specify which instance the method is being added to' \
           "add_method(:#{method}).to(instance)"
       end
 
-      def initialize(method = nil)
+      # @param method [String/Symbol] the method, to be checked, name
+      def initialize(method)
         @method = method
       end
 
-      def to(instance = nil)
-        AddMethodTo.new(instance, method)
+      # @return [AddMethodTo] the correct matcher
+      # @overload to(klass)
+      #   @param [Class] klass
+      #     class where the method should be added to
+      #
+      # @overload to(instance)
+      #   @param [Object] instance
+      #     instance of the class where the method should be added to
+      def to(target = nil)
+        AddMethodTo.new(target, method)
       end
 
       def equal?(other)
@@ -21,9 +31,14 @@ class Sinclair
         other.method == method
       end
 
+      # definition needed for block matchers
       def supports_block_expectations?
         true
       end
+
+      protected
+
+      attr_reader :method
     end
   end
 end

data/lib/sinclair/matchers/add_method_to.rb

@@ -1,37 +1,76 @@
 class Sinclair
   module Matchers
+    # AddMethodTo checks whether a method was or not added by the call of a block
+    #
+    # This is used with a RSpec DSL method add_method(method_name).to(class_object)
+    #
+    # @author darthjee
+    #
+    # @example
+    #  RSpec.configure do |config|
+    #    config.include Sinclair::Matchers
+    #  end
+    #
+    #  class MyModel
+    #  end
+    #
+    #  RSpec.describe 'my test' do
+    #    let(:klass)   { Class.new(MyModel) }
+    #    let(:builder) { Sinclair.new(klass) }
+    #
+    #    before do
+    #      builder.add_method(:class_name, 'self.class.name')
+    #    end
+    #
+    #    it do
+    #      expect { builder.build }.to add_method(:class_name).to(klass)
+    #    end
+    #  end
     class AddMethodTo < RSpec::Matchers::BuiltIn::BaseMatcher
-      attr_reader :method, :instance
-
-      def initialize(instance, method)
-        if instance.is_a?(Class)
-          @instance_class = instance
+      # @overload initialize(klass, method)
+      #   @param [Class] klass
+      #     class where the method should be added to
+      #
+      # @overload initialize(instance, method)
+      #   @param [Object] klass
+      #     instance of the class where the method should be added to
+      #
+      # @param method
+      #   method name
+      def initialize(target, method)
+        if target.is_a?(Class)
+          @klass = target
         else
-          @instance = instance
+          @instance = target
         end
         @method = method
       end
 
+      # @return [String] expectation description
       def description
-        "add method '#{method}' to #{instance_class} instances"
+        "add method '#{method}' to #{klass} instances"
       end
 
+      # @return [String] message on expectation failure
       def failure_message_for_should
-        "expected '#{method}' to be added to #{instance_class} but " \
+        "expected '#{method}' to be added to #{klass} but " \
           "#{@initial_state ? 'it already existed' : "it didn't"}"
       end
 
+      # @return [String] message on expectation failure for negative expectation
       def failure_message_for_should_not
-        "expected '#{method}' not to be added to #{instance_class} but it was"
+        "expected '#{method}' not to be added to #{klass} but it was"
       end
 
+      # @return [Boolean] expectation check
       def matches?(event_proc)
         return false unless event_proc.is_a?(Proc)
         raise_block_syntax_error if block_given?
         perform_change(event_proc)
-        changed?
+        added?
       end
 
+      # definition needed for block matchers
       def supports_block_expectations?
         true
       end
@@ -44,7 +83,11 @@ class Sinclair
 
       protected
 
-      def changed?
+      attr_reader :method, :instance
+
+      private
+
+      def added?
         !@initial_state && @final_state
       end
 
@@ -55,11 +98,11 @@ class Sinclair
       end
 
       def method_defined?
-        instance_class.method_defined?(method)
+        klass.method_defined?(method)
       end
 
-      def instance_class
-        @instance_class ||= instance.class
+      def klass
+        @klass ||= instance.class
       end
 
       def raise_block_syntax_error

data/lib/sinclair/method_definition.rb

@@ -1,35 +1,52 @@
-class Sinclair::MethodDefinition
-  attr_reader :name, :code, :block
-
-  def initialize(name, code = nil, &block)
-    @name = name
-    @code = code
-    @block = block
-  end
+class Sinclair
+  # Definition of the code or block to be aded as method
+  class MethodDefinition
+    # @overload initialize(name, code)
+    # @overload initialize(name, &block)
+    #
+    # @param name  [String/Symbol] name of the method
+    # @param code  [String] code to be evaluated as method
+    # @param block [Proc] block with code to be added as method
+    #
+    # @example
+    #   Sinclair::Method.new(:name, '@name')
+    #
+    # @example
+    #   Sinclair::Method.new(:name) { @name }
+    def initialize(name, code = nil, &block)
+      @name = name
+      @code = code
+      @block = block
+    end
 
-  def build(clazz)
-    if code.is_a?(String)
-      build_code_method(clazz)
-    else
-      build_block_method(clazz)
+    # Adds the method to given klass
+    # @param klass [Class] class which will receive the new method
+    def build(klass)
+      if code.is_a?(String)
+        build_code_method(klass)
+      else
+        build_block_method(klass)
+      end
     end
-  end
 
-  private
+    private
 
-  def build_block_method(clazz)
-    clazz.send(:define_method, name, block)
-  end
+    attr_reader :name, :code, :block
 
-  def build_code_method(clazz)
-    clazz.module_eval(code_definition, __FILE__, __LINE__ + 1)
-  end
+    def build_block_method(klass)
+      klass.send(:define_method, name, block)
+    end
 
-  def code_definition
-    <<-CODE
+    def build_code_method(klass)
+      klass.module_eval(code_definition, __FILE__, __LINE__ + 1)
+    end
+
+    def code_definition
+      <<-CODE
       def #{name}
         #{code}
       end
-    CODE
+      CODE
+    end
   end
 end

data/lib/sinclair/options_parser.rb

@@ -1,9 +1,35 @@
-module Sinclair::OptionsParser
-  extend ActiveSupport::Concern
+class Sinclair
+  # Concern for easily adding options
+  #
+  # @example
+  #   class Sinclair
+  #     class OptionsParser::Dummy
+  #       include OptionsParser
+  #
+  #       def initialize(options)
+  #         @options = options.deep_dup
+  #       end
+  #     end
+  #
+  #     def the_method
+  #       return 'missing option' if options_object.switch.nil?
+  #
+  #       if options_object.switch
+  #         "The value is #{options_object.option_1}"
+  #       else
+  #         "The value is not #{options_object.option_1} but #{options_object.option_2}"
+  #       end
+  #     end
+  #   end
+  module OptionsParser
+    extend ActiveSupport::Concern
 
-  attr_reader :options
+    private
 
-  def options_object
-    @options_object ||= OpenStruct.new options
+    attr_reader :options
+
+    def options_object
+      @options_object ||= OpenStruct.new options
+    end
   end
 end

data/lib/sinclair/version.rb

@@ -1,4 +1,4 @@
 class Sinclair
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
 end
 

data/sinclair.gemspec

@@ -25,5 +25,6 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'simplecov', '~> 0.16.1'
   gem.add_development_dependency 'rubocop'
   gem.add_development_dependency 'pry-nav'
+  gem.add_development_dependency 'yard'
 end
 

data/spec/integration/readme/my_class_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe MyClass do
-  subject { clazz.new(attributes) }
-  let(:clazz) { MyClass }
+  subject { klass.new(attributes) }
+  let(:klass) { MyClass }
   let(:name) { 'name' }
   let(:age) { 20 }
   let(:attributes) do

data/spec/integration/readme_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe 'Stand Alone' do
-  let(:instance) { clazz.new }
-  let(:clazz) { Class.new }
-  let(:builder) { Sinclair.new(clazz) }
+  let(:instance) { klass.new }
+  let(:klass) { Class.new }
+  let(:builder) { Sinclair.new(klass) }
 
   before do
     builder.add_method(:twenty, '10 + 10')

data/spec/integration/yard/matchers/add_method_to_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'yard' do
+  describe Sinclair::Matchers::AddMethodTo do
+    let(:klass)   { Class.new(MyModel) }
+    let(:builder) { Sinclair.new(klass) }
+
+    before do
+      builder.add_method(:class_name, 'self.class.name')
+    end
+
+    it do
+      expect { builder.build }.to add_method(:class_name).to(klass)
+    end
+  end
+end

data/spec/integration/yard/options_parser_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'yard' do
+  describe Sinclair::OptionsParser do
+    let(:options) { { switch: false, option_1: 10, option_2: 20 } }
+    subject { described_class::Dummy.new(options) }
+
+    describe '#the_method' do
+      it 'returns the value for option given' do
+        expect(subject.the_method).to eq('The value is not 10 but 20')
+      end
+    end
+  end
+end

data/spec/integration/yard/sinclair_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe 'yarn' do
+  describe Sinclair do
+    let(:klass)    { Class.new(MyModel) }
+    let(:instance) { klass.new }
+    let(:builder)  { Sinclair.new(klass) }
+    let(:default_value) { 10 }
+
+    describe '#initialize' do
+      describe '#total_price' do
+        before do
+          subject.eval_and_add_method(:total_price) do
+            code = 'self.value * self.quantity'
+            code.concat ' rescue 0' if options_object.rescue_error
+            code
+          end
+
+          subject.build
+        end
+
+        context 'without options' do
+          subject { Sinclair.new(klass, rescue_error: true) }
+
+          let(:klass) { Class.new(Purchase) }
+          let(:instance) { klass.new(2.3, 5) }
+
+          it 'evaluates into default_value' do
+            expect(instance.total_price).to eq(0)
+          end
+        end
+
+        context 'with options' do
+          subject { Sinclair.new(klass) }
+
+          let(:klass) { Class.new(Purchase) }
+          let(:instance) { klass.new(2.3, 5) }
+
+          it do
+            expect { instance.total_price }.to raise_error(NoMethodError)
+          end
+
+          context 'with attribute readers' do
+            before do
+              klass.send(:attr_reader, :value, :quantity)
+            end
+
+            it 'calculates total price' do
+              expect(instance.total_price).to eq(11.5)
+            end
+          end
+        end
+      end
+    end
+
+    describe '#build' do
+      before do
+        value = default_value
+        builder.add_method(:default_value) { value }
+        builder.add_method(:value, '@value || default_value')
+        builder.add_method(:value=) { |val| @value = val }
+      end
+
+      context 'after the build' do
+        before { builder.build }
+        it 'creates the expected methods' do
+          expect(instance.value).to eq(10)
+        end
+
+        context 'when default value is overwritten' do
+          before do
+            instance.value = 20
+          end
+
+          it 'returns the new written value' do
+            expect(instance.value).to eq(20)
+          end
+        end
+      end
+
+      context 'calling the build' do
+        it do
+          expect do
+            builder.build
+          end.to change { instance.respond_to?(:default_value) }.to(true)
+        end
+      end
+    end
+
+    describe '#add_method' do
+      let(:klass) { Class.new(Person) }
+      let(:instance) { klass.new('john', 'wick') }
+
+      before do
+        builder.add_method(:full_name, '[first_name, last_name].join(" ")')
+        builder.add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
+        builder.build
+      end
+
+      describe '#full_name' do
+        let(:klass) { Class.new(Person) }
+        let(:instance) { klass.new('john', 'wick') }
+
+        before do
+          builder.add_method(:full_name, '[first_name, last_name].join(" ")')
+          builder.build
+        end
+
+        it 'returns the full name' do
+          expect(instance.bond_name).to eq('wick, john wick')
+        end
+      end
+
+      describe '#bond_style' do
+      end
+    end
+
+    describe '#eval_and_add_method' do
+      subject { klass.new }
+
+      let(:klass) do
+        Class.new do
+          include InitialValuer
+          attr_writer :age
+          initial_value_for :age, 20
+        end
+      end
+
+      describe '#age' do
+        context 'when it has not been initialized' do
+          it do
+            expect(subject.age).to eq(20)
+          end
+        end
+
+        context 'when it has been initialized' do
+          before do
+            subject.age
+            subject.age = 30
+          end
+
+          it do
+            expect(subject.age).to eq(30)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/sinclair/method_definition_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Sinclair::MethodDefinition do
-  let(:clazz) { Class.new }
-  let(:instance) { clazz.new }
+  let(:klass) { Class.new }
+  let(:instance) { klass.new }
 
   describe '#build' do
     let(:method_name) { :the_method }
@@ -13,10 +13,10 @@ describe Sinclair::MethodDefinition do
       subject { described_class.new(method_name, code) }
 
       before do
-        subject.build(clazz)
+        subject.build(klass)
       end
 
-      it 'adds the method to the clazz instance' do
+      it 'adds the method to the klass instance' do
         expect(instance).to respond_to(method_name)
       end
 
@@ -33,10 +33,10 @@ describe Sinclair::MethodDefinition do
       end
 
       before do
-        subject.build(clazz)
+        subject.build(klass)
       end
 
-      it 'adds the method to the clazz instance' do
+      it 'adds the method to the klass instance' do
         expect(instance).to respond_to(method_name)
       end
 

data/spec/lib/sinclair/options_parser_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe Sinclair::OptionsParser do
-  let(:clazz) { described_class::Dummy }
+  let(:klass) { described_class::Dummy }
   let(:switched) { true }
   let(:value_1) { 'value1' }
   let(:options) { { switch: switched, option_1: value_1, option_2: 2} }
 
   subject do
-    clazz.new(options)
+    klass.new(options)
   end
 
   it 'enables the given options to be acced' do

data/spec/support/models/initial_valuer.rb

@@ -0,0 +1,13 @@
+module InitialValuer
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def initial_value_for(attribute, value)
+      builder = Sinclair.new(self, initial_value: value)
+      builder.eval_and_add_method(attribute) do
+        "@#{attribute} ||= #{options_object.initial_value}"
+      end
+      builder.build
+    end
+  end
+end

data/spec/support/models/my_model.rb

@@ -0,0 +1,2 @@
+class MyModel
+end

data/spec/support/models/person.rb

@@ -0,0 +1,8 @@
+class Person
+  attr_reader :first_name, :last_name
+
+  def initialize(first_name, last_name)
+    @first_name = first_name
+    @last_name = last_name
+  end
+end

data/spec/support/models/purchase.rb

@@ -0,0 +1,6 @@
+class Purchase
+  def initialize(value, quantity)
+    @value = value
+    @quantity = quantity
+  end
+end

data/spec/support/models/validator_builder.rb

@@ -1,7 +1,7 @@
 class ValidationBuilder < Sinclair
   delegate :expected, to: :options_object
 
-  def initialize(clazz, options={})
+  def initialize(klass, options={})
     super
   end
 
@@ -10,6 +10,6 @@ class ValidationBuilder < Sinclair
   end
 
   def add_accessors(fields)
-    clazz.send(:attr_accessor, *fields)
+    klass.send(:attr_accessor, *fields)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinclair
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - DarthJee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-03 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: Gem for easy concern creation
 email:
 - darthjee@gmail.com
@@ -138,6 +152,9 @@ files:
 - spec/integration/readme/matcher_spec.rb
 - spec/integration/readme/my_class_spec.rb
 - spec/integration/readme_spec.rb
+- spec/integration/yard/matchers/add_method_to_spec.rb
+- spec/integration/yard/options_parser_spec.rb
+- spec/integration/yard/sinclair_spec.rb
 - spec/lib/sinclair/matchers/add_method_spec.rb
 - spec/lib/sinclair/matchers/add_method_to_spec.rb
 - spec/lib/sinclair/matchers_spec.rb
@@ -148,9 +165,13 @@ files:
 - spec/support/fixture_helpers.rb
 - spec/support/models/dummy_builder.rb
 - spec/support/models/dummy_options_parser.rb
+- spec/support/models/initial_valuer.rb
 - spec/support/models/my_builder.rb
 - spec/support/models/my_class.rb
 - spec/support/models/my_concern.rb
+- spec/support/models/my_model.rb
+- spec/support/models/person.rb
+- spec/support/models/purchase.rb
 - spec/support/models/validator_builder.rb
 homepage: https://github.com/darthjee/sinclair
 licenses: []