sinclair 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8078be623117ced163bf463e484e1e2553781dc3ebf379e48a98dc5c3e710079
-  data.tar.gz: 5edfd7356786a04ee94f5bfff56fd954e26b52b5fa4ef7eb3372ddd33ddb6c80
+  metadata.gz: c574eec3a6df9fca413808866c33a03da39ac3aea5a55ad588ea0532fdcb8058
+  data.tar.gz: ccdf5e26711abfeb0c9a2eee9f59cabc8a4ae912b624b976720b228b7be7adbd
 SHA512:
-  metadata.gz: 03b32dcf796be1331442a673040264bc2cb215f1ad2eb657aaf416f76bea0e6aaca71ccb8bd356e5c9ab094dc31f4d2a0c3cc4dc607ccb39db429b864b5e785c
-  data.tar.gz: 28bd3ed7dea51f96d82bdbbdb64588762cc017ab92d8847045dbf33beb8aa83abc71869ff5e55f4f8dc72f4f29f4f9907596702acb7ab5f456c43bc0b92e902b
+  metadata.gz: 807968f16b1be5c991e7377aa888fc70548c8058945e7f137a6cfa53ef4a6359c5be19305a5184f8d2b1d7ed8343d815a8595b9deef8b1f266c7e5fbca4bc94f
+  data.tar.gz: 2dc1e2cbf9e95829d488e49ee6835775d99cc9743313b0b58ea50fc2ac739a471ecd98da35c9193dc631bcbfdfabe6cb665fa190a97afacf4b4d4ecfec9dde95

data/.rubocop.yml

@@ -7,6 +7,7 @@ AllCops:
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*_spec.rb'
+    - 'spec/support/**/*.rb'
 
 Metrics/LineLength:
   Max: 100
@@ -20,12 +21,16 @@ RSpec/AlignLeftLetBrace:
 
 RSpec/InstanceVariable:
   Exclude:
-    - 'spec/integration/yard/sinclair/method_definition_spec.rb'
-    - 'spec/lib/sinclair/method_definition_spec.rb'
+    - spec/integration/yard/sinclair/method_definition_spec.rb
+    - spec/integration/yard/sinclair/method_definition/block_definition_spec.rb
+    - spec/lib/sinclair/method_definition/block_definition_spec.rb
+    - spec/lib/sinclair/method_definition_spec.rb
 
 RSpec/MultipleExpectations:
   Exclude:
     - spec/integration/yard/sinclair/method_definition_spec.rb
+    - spec/integration/yard/sinclair/method_definition/block_definition_spec.rb
+    - spec/integration/yard/sinclair/method_definition/string_definition_spec.rb
     - spec/lib/sinclair_spec.rb
     - spec/integration/readme/my_model_spec.rb
 

data/Dockerfile

@@ -1,4 +1,4 @@
-FROM darthjee/ruby_gems:0.0.1 as base
+FROM darthjee/ruby_gems:0.1.0 as base
 FROM darthjee/scripts:0.0.2 as scripts
 
 ######################################

data/README.md

@@ -8,11 +8,13 @@ Sinclair
 
 ![sinclair](https://raw.githubusercontent.com/darthjee/sinclair/master/sinclair.jpg)
 
-This gem helps the creation of complex concern with class methods
+This gem helps the creation of complex gems/concerns
+that enables creation of methods on the fly through class
+methods
 
 Yard Documentation
 -------------------
-https://www.rubydoc.info/gems/sinclair/1.3.0
+https://www.rubydoc.info/gems/sinclair/1.3.1
 
 Installation
 ---------------
@@ -22,7 +24,7 @@ Installation
   gem install sinclair
 ```
 
-  - Or add Sinclairn to your `Gemfile` and `bundle install`:
+  - Or add Sinclair to your `Gemfile` and `bundle install`:
 
 ```ruby
   gem 'sinclair'
@@ -34,10 +36,12 @@ Installation
 
 Usage
 ---------------
-The concern builder can actully be used in two ways, as an stand alone object capable of
-adding methods to your class or by extending it for more complex logics
+# Sinclair
+Sinclair can actully be used in several ways, as an stand alone object capable of
+adding methods to your class on the fly, as a builder inside a class method
+or by extending it for more complex logics
 
- - Stand Alone usage:
+## Stand Alone usage creating methods on the fly:
 
 ```ruby
 
@@ -56,18 +60,78 @@ adding methods to your class or by extending it for more complex logics
   puts "Eighty => #{instance.eighty}" # Eighty => 80
 ```
 
- - Extending the builder
+## Builder in class method:
 
 ```ruby
+  class HttpJsonModel
+    attr_reader :json
 
-  class ValidationBuilder < Sinclair
-    delegate :expected, to: :options_object
+    class << self
+      def parse(attribute, path: [])
+        builder = Sinclair.new(self)
+
+        keys = (path + [attribute]).map(&:to_s)
+
+        builder.add_method(attribute) do
+          keys.inject(hash) { |h, key| h[key] }
+        end
+
+        builder.build
+      end
+    end
 
-    def initialize(klass, options={})
-      super
+    def initialize(json)
+      @json = json
     end
 
-    def add_validation(field)
+    def hash
+      @hash ||= JSON.parse(json)
+    end
+  end
+
+  class HttpPerson < HttpJsonModel
+    parse :uid
+    parse :name,     path: [:personal_information]
+    parse :age,      path: [:personal_information]
+    parse :username, path: [:digital_information]
+    parse :email,    path: [:digital_information]
+  end
+
+  json = <<-JSON
+    {
+      "uid": "12sof511",
+      "personal_information":{
+        "name":"Bob",
+        "age": 21
+      },
+      "digital_information":{
+        "username":"lordbob",
+        "email":"lord@bob.com"
+      }
+    }
+  JSON
+
+  person = HttpPerson.new(json)
+
+  person.uid      # returns '12sof511'
+  person.name     # returns 'Bob'
+  person.age      # returns 21
+  person.username # returns 'lordbob'
+  person.email    # returns 'lord@bob.com'
+```
+
+## Extending the builder
+
+```ruby
+
+  class ValidationBuilder < Sinclair
+     delegate :expected, to: :options_object
+
+     def initialize(klass, options={})
+       super
+     end
+
+     def add_validation(field)
       add_method("#{field}_valid?", "#{field}.is_a?#{expected}")
     end
 
@@ -149,9 +213,12 @@ adding methods to your class or by extending it for more complex logics
   invalid_object.valid? # returns false
 ```
 
-  - Caching the result
-    If wanted, the result of the method can be stored in an
-    instance variable with the same name
+## Caching the result
+If wanted, the result of the method can be stored in an
+instance variable with the same name.
+
+When caching, you can cache with type `:full` so that even `nil`
+values are cached
 
 ```ruby
   class MyModel
@@ -178,6 +245,92 @@ adding methods to your class or by extending it for more complex logics
   model.cached_power # returns 9 (from cache)
 ```
 
+```ruby
+  module DefaultValueable
+    def default_reader(*methods, value:, accept_nil: false)
+      DefaultValueBuilder.new(
+        self, value: value, accept_nil: accept_nil
+      ).add_default_values(*methods)
+    end
+  end
+
+  class DefaultValueBuilder < Sinclair
+    def add_default_values(*methods)
+      default_value = value
+
+      methods.each do |method|
+        add_method(method, cached: cache_type) { default_value }
+      end
+
+      build
+    end
+
+    private
+
+    delegate :accept_nil, :value, to: :options_object
+
+    def cache_type
+      accept_nil ? :full : :simple
+    end
+  end
+
+  class Server
+    extend DefaultValueable
+
+    attr_writer :host, :port
+
+    default_reader :host, value: 'server.com', accept_nil: false
+    default_reader :port, value: 80,           accept_nil: true
+
+    def url
+      return "http://#{host}" unless port
+
+      "http://#{host}:#{port}"
+    end
+  end
+
+  server = Server.new
+
+  server.url # returns 'http://server.com:80'
+
+  server.host = 'interstella.com'
+  server.port = 5555
+  server.url # returns 'http://interstella.com:5555'
+
+  server.host = nil
+  server.port = nil
+  server.url # return 'http://server.com'
+```
+
+# Sinclair::Configurable
+
+Configurable is a module that, when used, can add configurations
+to your classes/modules.
+
+Configurations are read-only objects that can only be set using
+the `configurable#configure` method
+
+```ruby
+  class MyConfigurable
+    extend Sinclair::Configurable
+
+    configurable_with :host, :port
+  end
+
+  MyConfigurable.configure do |config|
+    config.host 'interstella.art'
+    config.port 5555
+  end
+
+  MyConfigurable.config.host # returns 'interstella.art'
+  MyConfigurable.config.port # returns 5555
+
+  MyConfigurable.reset_config
+
+  MyConfigurable.config.host # returns nil
+  MyConfigurable.config.port # returns nil
+```
+
 RSspec matcher
 ---------------
 

data/config/yardstick.yml

@@ -41,9 +41,12 @@ rules:
       - Sinclair::Matchers::AddMethod#method
       - Sinclair::Matchers::AddMethodTo#method
       - Sinclair::Matchers::AddMethodTo#instance
+      - Sinclair::MethodDefinition#initialize
       - Sinclair::MethodDefinition#name
       - Sinclair::MethodDefinition#code
       - Sinclair::MethodDefinition#block
+      - Sinclair::MethodDefinition::BlockDefinition#initialize
+      - Sinclair::MethodDefinition::StringDefinition#initialize
       - Sinclair::OptionsParser#options
       - Sinclair::OptionsParser#options_object
       - Sinclair::ConfigFactory#initialize

data/lib/sinclair.rb

@@ -24,6 +24,61 @@ require 'active_support/all'
 #   instance.value # returns 10
 #   instance.value = 20
 #   instance.value # returns 20
+#
+# @example Usin cache
+#   module DefaultValueable
+#     def default_reader(*methods, value:, accept_nil: false)
+#       DefaultValueBuilder.new(
+#         self, value: value, accept_nil: accept_nil
+#       ).add_default_values(*methods)
+#     end
+#   end
+#
+#   class DefaultValueBuilder < Sinclair
+#     def add_default_values(*methods)
+#       default_value = value
+#
+#       methods.each do |method|
+#         add_method(method, cached: cache_type) { default_value }
+#       end
+#
+#       build
+#     end
+#
+#     private
+#
+#     delegate :accept_nil, :value, to: :options_object
+#
+#     def cache_type
+#       accept_nil ? :full : :simple
+#     end
+#   end
+#
+#   class Server
+#     extend DefaultValueable
+#
+#     attr_writer :host, :port
+#
+#     default_reader :host, value: 'server.com', accept_nil: false
+#     default_reader :port, value: 80,           accept_nil: true
+#
+#     def url
+#       return "http://#{host}" unless port
+#
+#       "http://#{host}:#{port}"
+#     end
+#   end
+#   server = Server.new
+#
+#   server.url # returns 'http://server.com:80'
+#
+#   server.host = 'interstella.com'
+#   server.port = 5555
+#   server.url # returns 'http://interstella.com:5555'
+#
+#   server.host = nil
+#   server.port = nil
+#   server.url # return 'http://server.com'
 class Sinclair
   require 'sinclair/options_parser'
 
@@ -149,7 +204,7 @@ class Sinclair
   #   Person.new('john', 'wick').bond_name # returns 'wick, john wick'
   # @return [Array<MethodDefinition>]
   def add_method(name, code = nil, **options, &block)
-    definitions << MethodDefinition.new(name, code, **options, &block)
+    definitions << MethodDefinition.from(name, code, **options, &block)
   end
 
   # Evaluetes a block which will result in a String, the method code

data/lib/sinclair/method_definition.rb

@@ -7,45 +7,50 @@ class Sinclair
   # Definition of the code or block to be aded as method
   class MethodDefinition
     include Sinclair::OptionsParser
+
+    autoload :BlockDefinition, 'sinclair/method_definition/block_definition'
+    autoload :StringDefinition, 'sinclair/method_definition/string_definition'
+
     # Default options of initialization
     DEFAULT_OPTIONS = {
       cached: false
     }.freeze
 
-    # Returns a new instance of MethodDefinition
-    #
-    # @overload initialize(name, code)
-    #   @example
-    #     Sinclair::MethodDefinition.new(:name, '@name')
-    #
-    # @overload initialize(name, &block)
-    #   @example
-    #     Sinclair::MethodDefinition.new(:name) { @name }
-    #
+    # Creates a new instance based on arguments
+    #
+    # @return [MethodDefinition] When block is given, a
+    #   new instance of {BlockDefinition} is returned,
+    #   otherwise {StringDefinition} is returned
+    def self.from(name, code = nil, **options, &block)
+      if block
+        BlockDefinition.new(name, **options, &block)
+      else
+        StringDefinition.new(name, code, **options)
+      end
+    end
+
     # @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
     # @param options [Hash] Options of construction
     # @option options cached [Boolean] Flag telling to create
     #   a method with cache
-    def initialize(name, code = nil, **options, &block)
+    def initialize(name, **options)
       @name =    name
-      @code =    code
       @options = DEFAULT_OPTIONS.merge(options)
-      @block =   block
     end
 
     # Adds the method to given klass
     #
-    # @param klass [Class] class which will receive the new method
+    # This should be implemented on child classes
     #
-    # @example Using string method with no options
+    # @param _klass [Class] class which will receive the new method
+    #
+    # @example Using block method with no options
     #   class MyModel
     #   end
     #
     #   instance = MyModel.new
     #
-    #   method_definition = Sinclair::MethodDefinition.new(
+    #   method_definition = Sinclair::MethodDefinition.from(
     #     :sequence, '@x = @x.to_i ** 2 + 1'
     #   )
     #
@@ -66,7 +71,7 @@ class Sinclair
     #
     #   instance = MyModel.new
     #
-    #   method_definition = Sinclair::MethodDefinition.new(:sequence) do
+    #   method_definition = Sinclair::MethodDefinition.from(:sequence) do
     #     @x = @x.to_i ** 2 + 1
     #   end
     #
@@ -83,12 +88,9 @@ class Sinclair
     #   instance.instance_variable_get(:@x)        # returns 1
     #
     # @return [Symbol] name of the created method
-    def build(klass)
-      if code.is_a?(String)
-        build_code_method(klass)
-      else
-        build_block_method(klass)
-      end
+    def build(_klass)
+      raise 'Build is implemented in subclasses. ' \
+        "Use #{self.class}.from to initialize a proper object"
     end
 
     private
@@ -103,57 +105,5 @@ class Sinclair
     #
     # @return [Boolean]
     alias cached? cached
-
-    # @private
-    #
-    # Add method from block
-    #
-    # @return [Symbol] name of the created method
-    def build_block_method(klass)
-      klass.send(:define_method, name, method_block)
-    end
-
-    # @private
-    #
-    # Returns the block that will be used for method creattion
-    #
-    # @return [Proc]
-    def method_block
-      return block unless cached?
-
-      inner_block = block
-      method_name = name
-
-      proc do
-        instance_variable_get("@#{method_name}") ||
-          instance_variable_set(
-            "@#{method_name}",
-            instance_eval(&inner_block)
-          )
-      end
-    end
-
-    # @private
-    #
-    # Add method from String code
-    #
-    # @return [Symbol] name of the created method
-    def build_code_method(klass)
-      klass.module_eval(code_definition, __FILE__, __LINE__ + 1)
-    end
-
-    # @private
-    #
-    # Builds full code of method
-    #
-    # @return [String]
-    def code_definition
-      code_line = cached? ? "@#{name} ||= #{code}" : code
-      <<-CODE
-      def #{name}
-        #{code_line}
-      end
-      CODE
-    end
   end
 end