attributes_dsl 0.0.1

data/config/metrics/STYLEGUIDE

@@ -0,0 +1,219 @@
+= Ruby Style Guide
+
+Adapted from Dan Kubb's Ruby Style Guide
+https://github.com/dkubb/styleguide/blob/master/RUBY-STYLE
+
+== Commiting:
+
+* Write descriptive commit messages, following the pattern:
+
+    [TYPE] name
+
+    The message, describing the changes being made
+
+* Use the types below to mark commits:
+
+  - NEW - for adding new features, or backward-compatible changes;
+  - CHANGE - for backward-incompatible changes;
+  - BUG FIX - for fixing bugs;
+  - INTERNAL - for other changes not affecting the API, including changes in documentaton, metrics etc.;
+  - VERSION - for version changes.
+
+* Always separate commits of different types.
+
+* Try to separate various features from each other.
+
+* Include unit tests to the same commit as the code. Ensure the code is 100% covered (use mutant!)
+
+* Run all tests before making a commit.
+  Never ever commit the code that breaks unit tests.
+
+* Use metric (run `rake check`) before making a commit.
+
+* Do refactoring before making a commit. Best writing is rewriting.
+
+* Follow semantic versioning.
+
+    http://semver.org/
+
+* For versions name the commit after a version number, following the pattern:
+
+    VERSION 1.0.0-rc2
+
+
+== Formatting:
+
+* Use UTF-8. Declare encoding in the first line of every file.
+
+    # encoding: utf-8
+
+* For every new class or method add comment with your name and email.
+    
+    # @author John Johnes <john.johnes@example.com>
+
+  This is necessary for others could send you they changes to review.
+
+* Use 2 space indent, no tabs.
+
+* Use Unix-style line endings.
+
+* Use spaces around operators, after commas, colons and semicolons,
+  around { and before }.
+
+* No spaces after (, [ and before ], ).
+
+* Align `when` and `else` with `case`.
+
+* Use an empty line before the return value of a method (unless it
+  only has one line), and an empty line between defs.
+
+* Use empty lines to break up a long method into logical paragraphs.
+
+* Keep lines fewer than 80 characters.
+
+* Strip trailing whitespace.
+
+
+== Syntax:
+
+* Write for the earliest version supported by the gem.
+
+* Use double quotes
+  
+    http://viget.com/extend/just-use-double-quoted-ruby-strings
+
+* Use def with parentheses when there are arguments.
+
+* Never use for, unless you exactly know why.
+
+* Never use then, except in case statements.
+
+* Use when x then ... for one-line cases.
+
+* Use &&/|| for boolean expressions, and/or for control flow. (Rule of thumb: If you have to use outer parentheses, you are using the wrong operators.)
+
+* Avoid double negation (!!), unless Null Objects are expected.
+  
+    http://devblog.avdi.org/2011/05/30/null-objects-and-falsiness
+
+* Avoid multiline ?:, use if.
+
+* Use {...} when defining blocks on one line. Use do...end for multiline blocks.
+
+* Avoid return where not required.
+
+* Use ||= freely.
+
+* Use OO regexps, and avoid =~ $0-9, $~, $` and $' when possible.
+
+* Do not use Enumerable#inject when the "memo" object does not change between iterations, use Enumerable#each_with_object instead.
+
+* Prefer `fetch` to `[]` syntax. Prefer block syntax to the second argument of `fetch`.
+
+
+== Naming:
+
+* Use snake_case for methods.
+
+* Use CamelCase for classes and modules. (Keep acronyms like HTTP, RFC, XML uppercase.)
+
+* Use SCREAMING_SNAKE_CASE for other constants.
+
+* Do not use single letter variable names. Avoid uncommunicative names.
+
+* Use consistent variable names. Try to keep the variable names close to the object class name.
+
+* Use names prefixed with _ for unused variables.
+
+* When defining a predicate method that compares against another object of a similar type, name the argument "other".
+
+* Prefer `map` over `collect`, `detect` over `find`, `select` over `find_all`.
+
+* Prefer `def self.method` to singleton methods.
+
+* Avoid alias when alias_method will do.
+
+
+== Comments:
+
+* Use YARD and its conventions for API documentation. Don't put an empty line between the comment block and the def.
+
+* Comments longer than a word are capitalized and use punctuation. Use one space after periods.
+
+* Avoid superfluous comments.
+
+
+== Code structuring:
+
+* Break code into packages, decoupled from the environment.
+
+* Wrap packages into gems.
+
+* Inject dependencies explicitly. Leave all outer references on the border of any package. Inside the package use internal references only.
+
+* Follow SOLID principles.
+
+    http://en.wikipedia.org/wiki/SOLID_(object-oriented_design)
+
+* Only give a method one purpose for existing.
+  
+  If you pass in a boolean to a method, what you're saying is that this method has two different behaviours. Just split it into two single purpose methods.
+  
+  If you have to use the words "AND" or "OR" to describe what the method does it probably does too much.
+
+* Avoid long methods. Try to keep them at no more than 6 lines long, and preferably 4 or less.
+
+  If sections of a method are logically separate by blank lines, then that's probably a sign that those sections should be split into separate methods.
+
+* Avoid hashes-as-optional-parameters. Does the method do too much?
+
+* Avoid long parameter lists.
+
+* Add "global" methods to Kernel (if you have to) and make them private.
+
+* Use OptionParser for parsing complex command line options and ruby -s for trivial command line options.
+
+* Avoid needless metaprogramming.
+
+
+== General:
+
+* Code in a functional way, avoid mutation when it makes sense.
+
+* Always freeze objects assigned to constants.
+
+  Freeze instances at the end of the `#initializer` method. Don't mutate the state of the instance after initialization.
+
+  Use either `deep_nine` or `adamantium` gems to make the object deeply frozen.
+
+* Do not mutate arguments unless that is the purpose of the method.
+
+* Try to have methods either return the state of the object and have
+  no side effects, or return self and have side effects. This is
+  otherwise known as Command-query separation (CQS):
+
+    http://en.wikipedia.org/wiki/Command-query_separation
+
+* Try following TRUE heuristics by Sandi Metz
+
+    http://designisrefactoring.com/2015/02/08/introducing-sandi-metz-true/
+
+* Do not mess around in core classes when writing libraries. Namespace your code inside the modules, or wrap core classes to decorators of your own.
+
+* Do not program defensively.
+  
+    http://www.erlang.se/doc/programming_rules.shtml#HDR11
+
+* Keep the code simple.
+
+* Don't overdesign.
+
+* Don't underdesign.
+
+* Avoid bugs.
+
+* Read other style guides and apply the parts that don't dissent with this list.
+
+* Be consistent.
+
+* Use common sense.

data/config/metrics/cane.yml

@@ -0,0 +1,5 @@
+---
+abc_max: "10"
+line_length: "80"
+no_doc: "y"
+no_readme: "y"

data/config/metrics/churn.yml

@@ -0,0 +1,6 @@
+---
+ignore_files:
+- spec
+- config
+minimum_churn_count: 0
+start_date: "1 year ago"

data/config/metrics/flay.yml

@@ -0,0 +1,2 @@
+---
+minimum_score: 8

data/config/metrics/metric_fu.yml

@@ -0,0 +1,14 @@
+---
+folders: # The list of folders to be used by any metric.
+- lib
+metrics: # The list of allowed metrics. The other metrics are disabled.
+- cane
+- churn
+- flay
+- flog
+- reek
+- roodi
+- saikuro
+format: html
+output: tmp/metric_fu
+verbose: false

data/config/metrics/reek.yml

@@ -0,0 +1 @@
+---

data/config/metrics/roodi.yml

@@ -0,0 +1,24 @@
+---
+AssignmentInConditionalCheck:
+CaseMissingElseCheck:
+ClassLineCountCheck:
+  line_count: 100
+ClassNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ClassVariableCheck:
+CyclomaticComplexityBlockCheck:
+  complexity: 3
+CyclomaticComplexityMethodCheck:
+  complexity: 4
+EmptyRescueBodyCheck:
+ForLoopCheck:
+MethodLineCountCheck:
+  line_count: 6
+MethodNameCheck:
+  pattern: !ruby/regexp /^[\||\^|\&|\!]$|^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+ModuleLineCountCheck:
+  line_count: 100
+ModuleNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ParameterNumberCheck:
+  parameter_count: 4

data/config/metrics/rubocop.yml

@@ -0,0 +1,72 @@
+---
+# settings added by the 'hexx-suit' module
+# output: "tmp/rubocop"
+# format: "html"
+
+AllCops:
+  Exclude:
+    - '**/db/schema.rb'
+
+Lint/HandleExceptions:
+  Exclude:
+    - '**/*_spec.rb'
+
+Lint/RescueException:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/AccessorMethodName:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/EmptyLinesAroundMethodBody:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Style/EmptyLineBetweenDefs:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Style/SingleLineMethods:
+  Exclude:
+    - '**/*_spec.rb'
+
+Style/SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+Style/SpecialGlobalVars:
+  Exclude:
+    - '**/Gemfile'
+    - '**/*.gemspec'
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrivialAccessors:
+  Exclude:
+    - '**/*_spec.rb'

data/config/metrics/saikuro.yml

@@ -0,0 +1,3 @@
+---
+warn_cyclo:  4
+error_cyclo: 6

data/config/metrics/simplecov.yml

@@ -0,0 +1,6 @@
+---
+output: tmp/coverage
+filters: # The list of paths to be excluded from coverage checkup
+- "spec/"
+- "config/"
+groups: []

data/config/metrics/yardstick.yml

@@ -0,0 +1,37 @@
+---
+# Settings added by the 'hexx-suit' gem
+output: "tmp/yardstick/output.log"
+path: "lib/**/*.rb"
+rules:
+  ApiTag::Presence:
+    enabled: true
+    exclude: []
+  ApiTag::Inclusion:
+    enabled: true
+    exclude: []
+  ApiTag::ProtectedMethod:
+    enabled: true
+    exclude: []
+  ApiTag::PrivateMethod:
+    enabled: false
+    exclude: []
+  ExampleTag:
+    enabled: true
+    exclude: []
+  ReturnTag:
+    enabled: true
+    exclude: []
+  Summary::Presence:
+    enabled: true
+    exclude: []
+  Summary::Length:
+    enabled: true
+    exclude: []
+  Summary::Delimiter:
+    enabled: true
+    exclude: []
+  Summary::SingleLine:
+    enabled: true
+    exclude: []
+threshold: 100
+verbose: false

data/lib/attributes_dsl.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+require "equalizer"
+require "ice_nine"
+
+# Simple DSL for PORO attributes
+#
+# @api public
+#
+# @author Andrew Kozin <Andrew.Kozin@gmail.com>
+#
+module AttributesDSL
+
+  require_relative "attributes_dsl/attribute"
+  require_relative "attributes_dsl/attributes"
+
+  # The mutable collection of declared attributes
+  #
+  # @return [AttributeDSL::Attributes]
+  #
+  # @api private
+  #
+  def attributes
+    @attributes ||= Attributes.new
+  end
+
+  # Retisters an attribute by name, options and coercer
+  #
+  # @example
+  #   class MyClass
+  #     extend AttributeDSL
+  #
+  #     attribute :foo, required: true do |value|
+  #       value.to_i % 5
+  #     end
+  #
+  #     attribute :bar, default: :BAR
+  #   end
+  #
+  # @param [#to_sym] name The unique name of the attribute
+  # @param [Proc] coercer The proc to coerce values (including the default ones)
+  # @param [Hash] options
+  #
+  # @option options [Boolean] :required
+  #   Whether the attribute should be required by the +initializer+
+  #   This option is ignored (set to +false+) when default value is provided
+  # @option options [Object] :default
+  #   The default value for the attribute
+  #
+  # @return [undefined]
+  #
+  def attribute(name, options = {}, &coercer)
+    s_name = name.to_sym
+    @attributes = attributes.register(s_name, options, &coercer)
+
+    define_method(s_name) { attributes.fetch(s_name) }
+  end
+
+  # Object contstructor that filters hash of attributes
+  #
+  # @param [Hash] hash The hash of attributes to be assinged
+  #
+  # @return [Object]
+  #
+  # @raise [ArgumentError] in case a required attribute is missed
+  #
+  def new(hash)
+    super attributes.extract(hash)
+  end
+
+  # @private
+  def self.extended(klass)
+    # use __send__ for compatibility to 1.9.3 (where `.include` was private)
+    klass.__send__(:include, InstanceMethods)
+  end
+
+  # Defines instance methods for the hash of attributes and its initializer
+  module InstanceMethods
+
+    # @!attribute [r] attributes
+    #
+    # @return [Hash] the hash of initialized attributes
+    #
+    attr_reader :attributes
+
+    # Initializes the object and sets the hash of its [#attributes]
+    #
+    # Uses attributes prepared by [.new]
+    #
+    # @param [Hash] attributes
+    #
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+  end # module InstanceMethods
+
+end # module AttributesDSL